@ilya-lesikov/pi-pi 0.6.0 → 0.7.0

package/extensions/orchestrator/pp-menu.ts

@@ -1,7 +1,7 @@
 import { existsSync, readdirSync, writeFileSync } from "fs";
-import { join, relative } from "path";
+import { join, relative, basename } from "path";
 import { isDeepStrictEqual } from "util";
-import { askUser, isCancel } from "../../3p/pi-ask-user/index.js";
+import { askUser, isCancel, type CancelReason } from "../../3p/pi-ask-user/index.js";
 import { unregisterAgentDefinitions } from "./agents/registry.js";
 import {
   type AfterEditCommandConfig,
@@ -44,6 +44,8 @@ import {
   saveTask,
   taskAge,
   taskName,
+  taskNameFromState,
+  taskShortId,
   type AutonomousConfig,
   type TaskMode,
   type TaskInfo,
@@ -53,6 +55,8 @@ import {
   clearFlantGeneratedConfig,
   getFlantGeneratedConfig,
   loadFlantSettings,
+  readClaudeOAuthToken,
+  readGatewayApiKey,
   saveFlantSettings,
   unregisterFlantProviders,
   updateFlantInfra,
@@ -67,6 +71,13 @@ type MenuMode = "command" | "tool";
 
 const BACK = "back" as const;
 
+// Sentinel returned by showActiveTaskMenu when the user dismissed the top-level
+// menu with a deliberate ESC (cancelReason "user"), as opposed to selecting the
+// "Back" option or a programmatic dismissal. Callers (pp_phase_complete) use it
+// to stop the turn cleanly instead of returning reminder text that starts a new
+// LLM turn. It is intentionally distinct from the empty-string "Back" return.
+export const USER_CANCELLED = "\u0000user-cancelled" as const;
+
 type OptionInput = string | { title: string; description?: string };
 
 type TimeoutKey =
@@ -81,6 +92,18 @@ function isEnabled(value: { enabled?: boolean } | undefined): boolean {
 }
 
 async function selectOption(ctx: any, question: string, options: OptionInput[]): Promise<string | undefined> {
+  return (await selectOptionCancelable(ctx, question, options)).choice;
+}
+
+// Like selectOption but also surfaces the cancel reason so callers can tell a
+// deliberate user ESC (reason "user") apart from a normal non-selection. Used by
+// showActiveTaskMenu so pp_phase_complete can stop the turn cleanly on ESC
+// (mirroring ask_user) while keeping the "Back" navigation reminder.
+async function selectOptionCancelable(
+  ctx: any,
+  question: string,
+  options: OptionInput[],
+): Promise<{ choice?: string; cancelReason?: CancelReason }> {
   const result = await askUser(ctx, {
     question,
     options,
@@ -88,8 +111,9 @@ async function selectOption(ctx: any, question: string, options: OptionInput[]):
     allowComment: false,
     allowMultiple: false,
   });
-  if (!result || isCancel(result) || result.kind !== "selection") return undefined;
-  return result.selections[0];
+  if (result && isCancel(result)) return { cancelReason: result.reason };
+  if (!result || result.kind !== "selection") return {};
+  return { choice: result.selections[0] };
 }
 
 function opt(title: string, description: string): OptionInput {
@@ -783,6 +807,20 @@ function flantStatusText(settings: FlantSettings): string {
     `Last updated: ${settings.lastUpdated ?? "never"}`,
     `Providers: pp-flant-anthropic (${providers.anthropic} models), pp-flant-openai (${providers.openai} models)`,
   ];
+  if (settings.subscription) {
+    const hasOAuth = !!readClaudeOAuthToken();
+    const hasGatewayKey = !!readGatewayApiKey();
+    const subActive = hasOAuth && hasGatewayKey;
+    lines.push(
+      `Personal subscription: on (${subActive ? `active — pp-flant-anthropic-sub, ${providers.anthropic} models` : "inactive"})`,
+    );
+    if (!subActive) {
+      if (!hasOAuth) lines.push("  - missing Claude OAuth token (run pi /login for Anthropic)");
+      if (!hasGatewayKey) lines.push("  - missing gateway key (set LLM_API_KEY or FLANT_API_KEY)");
+    }
+  } else {
+    lines.push("Personal subscription: off");
+  }
   if (assignments.length === 0) {
     lines.push("Role assignments: none");
   } else {
@@ -812,10 +850,12 @@ async function showFlantInfraMenu(orchestrator: Orchestrator, ctx: any): Promise
     const settings = loadFlantSettings();
     const enableLabel = `Enable: ${settings.enabled ? "ON" : "OFF"}`;
     const options: OptionInput[] = [enableLabel];
+    const subscriptionLabel = `Personal Claude subscription: ${settings.subscription ? "ON" : "OFF"}`;
     if (settings.enabled) {
       options.push(
         `Auto-update on startup: ${settings.autoUpdate ? "ON" : "OFF"}`,
         `Cache period: ${settings.cacheTTLDays} ${settings.cacheTTLDays === 1 ? "day" : "days"}`,
+        subscriptionLabel,
         "Update now",
         "Current status",
       );
@@ -852,6 +892,34 @@ async function showFlantInfraMenu(orchestrator: Orchestrator, ctx: any): Promise
       continue;
     }
 
+    if (choice === subscriptionLabel) {
+      const turningOn = !settings.subscription;
+      if (turningOn) {
+        if (!readClaudeOAuthToken()) {
+          ctx.ui.notify("No Claude OAuth token found. Log in to your personal Claude subscription in pi first (/login → Anthropic), then retry.", "warning");
+          continue;
+        }
+        if (!readGatewayApiKey()) {
+          ctx.ui.notify("Set LLM_API_KEY (or FLANT_API_KEY) for the gateway first.", "warning");
+          continue;
+        }
+      }
+      const next = { ...settings, subscription: turningOn };
+      saveFlantSettings(next);
+      const result = await updateFlantInfra(orchestrator.pi);
+      if (!result.ok) {
+        ctx.ui.notify(`Personal subscription ${turningOn ? "enable" : "disable"} failed: ${result.error ?? "unknown error"}`, "error");
+      } else {
+        ctx.ui.notify(
+          turningOn
+            ? "Personal Claude subscription ON — Claude roles now route through sub/claude-* (billed to your subscription); non-Claude roles stay on llm-api.flant.ru."
+            : "Personal Claude subscription OFF — Claude roles reverted to pp-flant-anthropic.",
+          "info",
+        );
+      }
+      continue;
+    }
+
     if (choice.startsWith("Cache period:")) {
       const selected = await selectOption(ctx, "Cache period", [
         { title: "1 day", description: "Refresh model metadata daily" },
@@ -899,17 +967,18 @@ function formatElapsedDuration(ms: number): string {
   return remMin > 0 ? `${hr}h ${remMin}m` : `${hr}h`;
 }
 
-function showUsage(ctx: any): void {
+export function showUsage(ctx: any): void {
   const tracker = (globalThis as any)[Symbol.for("pi-pi:usage-tracker")] as
     | {
         getTotalInputTokens(): number; getTotalOutputTokens(): number;
         getTotalCacheReadTokens(): number; getTotalCacheWriteTokens(): number;
+        getTotalProcessedInputTokens(): number;
         getTotalCost(): number; getCacheHitRate(): number;
         getMainInputTokens(): number; getMainOutputTokens(): number;
         getMainCacheReadTokens(): number; getMainCacheWriteTokens(): number;
         getMainCost(): number;
-        getPerModelUsage(): Record<string, { inputTokens: number; outputTokens: number; cacheReadTokens: number; cacheWriteTokens: number; cacheSupported: boolean; turns: number }>;
-        getSubagentList(): Array<{ description: string; agentType: string; modelId: string; inputTokens: number; outputTokens: number; cacheReadTokens: number; cacheWriteTokens: number; cacheSupported: boolean; cost: number; durationMs: number; toolUses: number }>;
+        getPerModelUsage(): Record<string, { inputTokens: number; outputTokens: number; cacheReadTokens: number; cacheWriteTokens: number; cacheSupported: boolean; turns: number; subscription: boolean }>;
+        getSubagentList(): Array<{ description: string; agentType: string; modelId: string; inputTokens: number; outputTokens: number; cacheReadTokens: number; cacheWriteTokens: number; cacheSupported: boolean; cost: number; durationMs: number; toolUses: number; subscription: boolean }>;
       }
     | undefined;
 
@@ -918,30 +987,52 @@ function showUsage(ctx: any): void {
     return;
   }
 
-  const totalInput = tracker.getTotalInputTokens();
+  // Token-weighted cache hit rate: cache reads over all processed input
+  // (uncached + cache read + cache write). Same formula everywhere so the
+  // total, per-model, and per-agent percentages are directly comparable.
+  const hitRate = (uncached: number, cacheRead: number, cacheWrite: number): number => {
+    const processed = uncached + cacheRead + cacheWrite;
+    return processed > 0 ? cacheRead / processed : 0;
+  };
+
+  // Compact one-line input part: total processed input with an inline
+  // uncached / cache read / cache write breakdown, e.g. "↑1.3k (u84 r1.0k w200)".
+  const inputPart = (uncached: number, cacheRead: number, cacheWrite: number, cacheSupported: boolean): string => {
+    const processed = uncached + cacheRead + cacheWrite;
+    const head = `↑${formatTokenCount(processed)}`;
+    if (!cacheSupported) return head;
+    return `${head} (u${formatTokenCount(uncached)} r${formatTokenCount(cacheRead)} w${formatTokenCount(cacheWrite)})`;
+  };
+
+  const totalUncachedInput = tracker.getTotalInputTokens();
   const totalOutput = tracker.getTotalOutputTokens();
   const totalCacheRead = tracker.getTotalCacheReadTokens();
+  const totalCacheWrite = tracker.getTotalCacheWriteTokens();
+  const totalProcessedInput = tracker.getTotalProcessedInputTokens();
   const totalCost = tracker.getTotalCost();
-  const totalCacheRate = (totalCacheRead + totalInput) > 0
-    ? totalCacheRead / (totalCacheRead + totalInput)
-    : 0;
+  const totalCacheRate = tracker.getCacheHitRate();
 
   const mainInput = tracker.getMainInputTokens();
   const mainOutput = tracker.getMainOutputTokens();
   const mainCacheRead = tracker.getMainCacheReadTokens();
+  const mainCacheWrite = tracker.getMainCacheWriteTokens();
   const mainCost = tracker.getMainCost();
   const models = tracker.getPerModelUsage();
   const subagents = tracker.getSubagentList();
 
-  const byModel = new Map<string, { input: number; output: number; cacheRead: number; cacheWrite: number; cacheSupported: boolean; cost: number }>();
+  const byModel = new Map<string, { input: number; output: number; cacheRead: number; cacheWrite: number; cacheSupported: boolean; cost: number; subscription: boolean }>();
   const mainModelEntries = Object.entries(models);
-  const mainTotalTokens = mainModelEntries.reduce((s, [, u]) => s + u.inputTokens + u.outputTokens, 0);
+  // Subscription (flat-rate) models contribute no dollars, so exclude their
+  // tokens from the proportional-share denominator or paid rows would be
+  // inflated and the sub/ rows would receive a spurious share.
+  const mainTotalTokens = mainModelEntries.reduce((s, [, u]) => s + (u.subscription ? 0 : u.inputTokens + u.outputTokens), 0);
   for (const [modelId, usage] of mainModelEntries) {
     const modelTokens = usage.inputTokens + usage.outputTokens;
-    const modelCostShare = mainTotalTokens > 0 ? mainCost * (modelTokens / mainTotalTokens) : 0;
+    const modelCostShare = usage.subscription || mainTotalTokens <= 0 ? 0 : mainCost * (modelTokens / mainTotalTokens);
     byModel.set(modelId, {
       input: usage.inputTokens, output: usage.outputTokens,
       cacheRead: usage.cacheReadTokens, cacheWrite: usage.cacheWriteTokens, cacheSupported: usage.cacheSupported, cost: modelCostShare,
+      subscription: usage.subscription,
     });
   }
   for (const sa of subagents) {
@@ -954,28 +1045,37 @@ function showUsage(ctx: any): void {
       existing.cacheWrite += sa.cacheWriteTokens;
       if (sa.cacheSupported) existing.cacheSupported = true;
       existing.cost += sa.cost;
+      if (sa.subscription) existing.subscription = true;
     } else {
       byModel.set(key, {
         input: sa.inputTokens, output: sa.outputTokens,
         cacheRead: sa.cacheReadTokens, cacheWrite: sa.cacheWriteTokens, cacheSupported: sa.cacheSupported, cost: sa.cost,
+        subscription: sa.subscription,
       });
     }
   }
 
+  // Total input the model processed = uncached + cache read + cache write.
+  // Shown as an explicit breakdown so the (often tiny) uncached sliver no
+  // longer masquerades as the whole "Input" figure.
   const lines: string[] = ["Session usage (total):"];
-  lines.push(`  Input: ${formatTokenCount(totalInput)} tokens`);
+  lines.push(`  Input: ${formatTokenCount(totalProcessedInput)} tokens`);
+  lines.push(`    • uncached:    ${formatTokenCount(totalUncachedInput)}`);
+  lines.push(`    • cache read:  ${formatTokenCount(totalCacheRead)}`);
+  lines.push(`    • cache write: ${formatTokenCount(totalCacheWrite)}`);
   lines.push(`  Output: ${formatTokenCount(totalOutput)} tokens`);
   if (totalCacheRead > 0) lines.push(`  Cache: ⚡${Math.round(totalCacheRate * 100)}% hit rate`);
-  if (totalCost > 0) lines.push(`  Cost: $${totalCost.toFixed(2)}`);
+  lines.push(`  Cost: $${totalCost.toFixed(2)}`);
 
   if (byModel.size > 0) {
     lines.push("");
     lines.push("By model:");
     for (const [modelId, m] of byModel) {
-      const cr = (m.cacheRead + m.input) > 0 ? Math.round(m.cacheRead / (m.cacheRead + m.input) * 100) : 0;
-      const parts = [`↑${formatTokenCount(m.input)}`, `↓${formatTokenCount(m.output)}`];
+      const cr = Math.round(hitRate(m.input, m.cacheRead, m.cacheWrite) * 100);
+      const parts = [inputPart(m.input, m.cacheRead, m.cacheWrite, m.cacheSupported), `↓${formatTokenCount(m.output)}`];
       if (m.cacheSupported) parts.push(`⚡${cr}%`);
-      if (m.cost > 0) parts.push(`$${m.cost.toFixed(2)}`);
+      if (m.subscription) parts.push("subscription");
+      else if (m.cost > 0) parts.push(`$${m.cost.toFixed(2)}`);
       lines.push(`  ${modelId}: ${parts.join("  ")}`);
     }
   }
@@ -985,13 +1085,15 @@ function showUsage(ctx: any): void {
   const agentModelNames = Object.keys(models);
   if (agentModelNames.length > 0) {
     const mainCacheSupported = mainModelEntries.some(([, u]) => u.cacheSupported);
-    const mainParts = [`↑${formatTokenCount(mainInput)}`, `↓${formatTokenCount(mainOutput)}`];
-    const mainCR = (mainCacheRead + mainInput) > 0 ? Math.round(mainCacheRead / (mainCacheRead + mainInput) * 100) : 0;
+    const mainAllSubscription = mainModelEntries.every(([, u]) => u.subscription);
+    const mainParts = [inputPart(mainInput, mainCacheRead, mainCacheWrite, mainCacheSupported), `↓${formatTokenCount(mainOutput)}`];
+    const mainCR = Math.round(hitRate(mainInput, mainCacheRead, mainCacheWrite) * 100);
     if (mainCacheSupported) mainParts.push(`⚡${mainCR}%`);
-    if (mainCost > 0) mainParts.push(`$${mainCost.toFixed(2)}`);
+    if (mainAllSubscription) mainParts.push("subscription");
+    else if (mainCost > 0) mainParts.push(`$${mainCost.toFixed(2)}`);
     lines.push(`  Main (${agentModelNames.join(", ")}): ${mainParts.join("  ")}`);
   }
-  const byAgentType = new Map<string, { input: number; output: number; cacheRead: number; cacheSupported: boolean; cost: number; durationMs: number; toolUses: number; count: number }>();
+  const byAgentType = new Map<string, { input: number; output: number; cacheRead: number; cacheWrite: number; cacheSupported: boolean; cost: number; durationMs: number; toolUses: number; count: number; subscriptionRuns: number }>();
   for (const sa of subagents) {
     const key = sa.agentType || sa.description;
     const existing = byAgentType.get(key);
@@ -999,24 +1101,29 @@ function showUsage(ctx: any): void {
       existing.input += sa.inputTokens;
       existing.output += sa.outputTokens;
       existing.cacheRead += sa.cacheReadTokens;
+      existing.cacheWrite += sa.cacheWriteTokens;
       if (sa.cacheSupported) existing.cacheSupported = true;
       existing.cost += sa.cost;
       existing.durationMs += sa.durationMs;
       existing.toolUses += sa.toolUses;
       existing.count += 1;
+      if (sa.subscription) existing.subscriptionRuns += 1;
     } else {
       byAgentType.set(key, {
-        input: sa.inputTokens, output: sa.outputTokens, cacheRead: sa.cacheReadTokens,
+        input: sa.inputTokens, output: sa.outputTokens, cacheRead: sa.cacheReadTokens, cacheWrite: sa.cacheWriteTokens,
         cacheSupported: sa.cacheSupported, cost: sa.cost, durationMs: sa.durationMs, toolUses: sa.toolUses, count: 1,
+        subscriptionRuns: sa.subscription ? 1 : 0,
       });
     }
   }
   for (const [agentType, agg] of byAgentType) {
-    const saCR = (agg.cacheRead + agg.input) > 0
-      ? Math.round(agg.cacheRead / (agg.cacheRead + agg.input) * 100) : 0;
-    const parts = [`↑${formatTokenCount(agg.input)}`, `↓${formatTokenCount(agg.output)}`];
+    const saCR = Math.round(hitRate(agg.input, agg.cacheRead, agg.cacheWrite) * 100);
+    const parts = [inputPart(agg.input, agg.cacheRead, agg.cacheWrite, agg.cacheSupported), `↓${formatTokenCount(agg.output)}`];
     if (agg.cacheSupported) parts.push(`⚡${saCR}%`);
-    if (agg.cost > 0) parts.push(`$${agg.cost.toFixed(2)}`);
+    // All runs subscription-routed → flat-rate label; otherwise show the
+    // paid-only summed cost (subscription runs already contribute $0).
+    if (agg.subscriptionRuns === agg.count) parts.push("subscription");
+    else if (agg.cost > 0) parts.push(`$${agg.cost.toFixed(2)}`);
     if (agg.durationMs > 0) parts.push(formatElapsedDuration(agg.durationMs));
     if (agg.toolUses > 0) parts.push(`${agg.toolUses} tools`);
     const countSuffix = agg.count > 1 ? ` (×${agg.count})` : "";
@@ -1085,6 +1192,7 @@ const ORCHESTRATOR_ROLES: Array<{ role: MainModelRole; label: string; descriptio
   { role: "plan", label: "Planner", description: "agents.orchestrators.plan" },
   { role: "debug", label: "Debugger", description: "agents.orchestrators.debug" },
   { role: "review", label: "Reviewer", description: "agents.orchestrators.review" },
+  { role: "quick", label: "Quick", description: "agents.orchestrators.quick" },
 ];
 
 const SUBAGENT_ROLES: Array<{ role: AgentRole; label: string; description: string }> = [
@@ -2737,14 +2845,59 @@ async function pickModeForTaskStart(
   }
 }
 
+// Title: scannable human-readable intent + age. Callers must guarantee
+// uniqueness across the menu (see buildResumeOptions) so the option->task
+// mapping stays stable.
 function resumeOptionTitle(t: TaskInfo): string {
-  return taskName(t.dir);
+  return `${taskNameFromState(t.dir, t.state)} — ${taskAge(t.state)}`;
 }
 
-function resumeOptionDescription(t: TaskInfo): string {
-  const age = taskAge(t.state);
-  const phase = t.state.phase === t.type ? t.type : `${t.type}/${t.state.phase}`;
-  return `${phase}, ${age}`;
+// Description: rich per-entry detail sourced entirely from the already-loaded
+// TaskState (no extra disk reads). Empty/irrelevant fields are omitted.
+function resumeOptionDescription(t: TaskInfo, cwd: string): string {
+  const s = t.state;
+  const parts: string[] = [];
+
+  const phaseStep = s.step ? `${s.phase}/${s.step}` : s.phase;
+  parts.push(`${t.type} · ${phaseStep}`);
+
+  const mode = s.effectiveMode ?? s.mode;
+  if (mode) parts.push(mode);
+
+  if (s.reviewCycle && s.reviewCycle.pass > 0) parts.push(`review pass ${s.reviewCycle.pass}`);
+
+  const fileCount = s.modifiedFiles?.length ?? 0;
+  if (fileCount > 0) parts.push(`${fileCount} file${fileCount === 1 ? "" : "s"}`);
+
+  // Only surface the repo when it is informative: a multi-repo task, or a root
+  // repo that differs from the current project directory.
+  const rootRepo = s.repos?.find((r) => r.isRoot) ?? s.repos?.[0];
+  if (rootRepo && ((s.repos?.length ?? 0) > 1 || basename(rootRepo.path) !== basename(cwd))) {
+    parts.push(`repo: ${basename(rootRepo.path)}`);
+  }
+
+  parts.push(`id ${taskShortId(t.dir)}`);
+  return parts.join(" · ");
+}
+
+// Build menu options with a stable option->task index. Titles are made unique
+// (short id appended on collision) so selection maps back deterministically even
+// if two tasks share an intent, and the age component can't break the mapping
+// after the picker returns.
+function buildResumeOptions(tasks: TaskInfo[], cwd: string): { options: OptionInput[]; byTitle: Map<string, TaskInfo> } {
+  const seen = new Map<string, number>();
+  const byTitle = new Map<string, TaskInfo>();
+  const options: OptionInput[] = [];
+  for (const t of tasks) {
+    let title = resumeOptionTitle(t);
+    const count = seen.get(title) ?? 0;
+    seen.set(title, count + 1);
+    if (count > 0 || byTitle.has(title)) title = `${title} [${taskShortId(t.dir)}]`;
+    while (byTitle.has(title)) title = `${title} ·`;
+    byTitle.set(title, t);
+    options.push({ title, description: resumeOptionDescription(t, cwd) });
+  }
+  return { options, byTitle };
 }
 
 async function showResumeMenu(
@@ -2760,16 +2913,13 @@ async function showResumeMenu(
       return BACK;
     }
 
-    const options: OptionInput[] = tasks.map((t) => ({
-      title: resumeOptionTitle(t),
-      description: resumeOptionDescription(t),
-    }));
+    const { options, byTitle } = buildResumeOptions(tasks, orchestrator.cwd);
     options.push({ title: "Back", description: "Return to the previous menu" });
 
     const choice = await selectOption(ctx, "Resume", options);
     if (!choice || choice === "Back") return BACK;
 
-    const task = tasks.find((t) => resumeOptionTitle(t) === choice);
+    const task = byTitle.get(choice);
     if (!task) continue;
     const result = await resumeTask(orchestrator, ctx, task);
     if (result.ok) return "started";
@@ -3251,13 +3401,16 @@ async function showQuickTaskMenu(
     if (summary !== "/pp") headerLines.push(`\n\n${summary}`);
     const menuTitle = headerLines.join("");
 
-    const choice = await selectOption(ctx, menuTitle, [
+    const { choice, cancelReason } = await selectOptionCancelable(ctx, menuTitle, [
       opt("Complete", "Mark task as done and clean up"),
       opt("Pause", "Suspend task to resume later"),
       opt("Info", "Subagents, usage, and task status"),
       opt("Settings", "Flant AI and other configuration"),
       opt("Back", "Return to the prompt and keep working"),
     ]);
+    // A deliberate ESC in tool mode must stop the turn cleanly (mirror the
+    // guided/autonomous branches); in command mode ESC just closes the menu.
+    if (cancelReason === "user" && mode === "tool") return USER_CANCELLED;
     if (!choice || choice === "Back") return "";
     if (choice === "Info") {
       await showInfoMenu(orchestrator, ctx);
@@ -3306,13 +3459,17 @@ export async function showActiveTaskMenu(
     const opt = (title: string, description: string): OptionInput => ({ title, description });
 
     if (effectiveMode === "autonomous") {
-      const autoChoice = await selectOption(ctx, `/pp\n\nTask: ${task.type}\nPhase: ${phase}${summary !== "/pp" ? `\n\n${summary}` : ""}`, [
+      const { choice: autoChoice, cancelReason } = await selectOptionCancelable(ctx, `/pp\n\nTask: ${task.type}\nPhase: ${phase}${summary !== "/pp" ? `\n\n${summary}` : ""}`, [
         opt("Complete task", "Mark task as done and clean up"),
         opt("Pause task", "Suspend task to resume later"),
         opt("Info", "Subagents, usage, and task status"),
         opt("Settings", "Flant AI and other configuration"),
         opt("Back", "Return to the prompt and keep working"),
       ]);
+      // A deliberate ESC only needs distinct handling in tool mode (so
+      // pp_phase_complete can stop the turn); in command mode ESC just closes
+      // the menu like "Back".
+      if (cancelReason === "user" && mode === "tool") return USER_CANCELLED;
       if (!autoChoice || autoChoice === "Back") return "";
       if (autoChoice === "Info") {
         await showInfoMenu(orchestrator, ctx);
@@ -3342,7 +3499,8 @@ export async function showActiveTaskMenu(
     const headerLines = [`/pp\n\nTask: ${task.type}\nPhase: ${phase}`];
     if (summary !== "/pp") headerLines.push(`\n\n${summary}`);
     const menuTitle = headerLines.join("");
-    const choice = await selectOption(ctx, menuTitle, options);
+    const { choice, cancelReason } = await selectOptionCancelable(ctx, menuTitle, options);
+    if (cancelReason === "user" && mode === "tool") return USER_CANCELLED;
     if (!choice || choice === "Back") {
       return "";
     }

package/extensions/orchestrator/state.ts

@@ -262,30 +262,51 @@ export function validateFromPath(cwd: string, fromPath: string): { ok: true; dir
 
 export function taskName(taskDir: string): string {
   try {
-    const state = loadTask(taskDir);
-    let desc = state.description ?? "";
-
-    if (["implement", "debug", "brainstorm", "review", "quick"].includes(desc)) {
-      const urPath = join(taskDir, "USER_REQUEST.md");
-      if (existsSync(urPath)) {
-        const content = readFileSync(urPath, "utf-8");
-        const lines = content.split("\n").map((l) => l.trim()).filter((l) => l.length > 0);
-        const firstContent = lines.find((l) => !l.startsWith("#"));
-        if (firstContent) desc = firstContent;
-      }
-    }
-
-    if (desc) {
-      desc = desc.replace(/\s+/g, " ").trim();
-      if (desc.length > 60) desc = desc.slice(0, 57) + "...";
-      return desc;
-    }
+    return taskNameFromState(taskDir, loadTask(taskDir));
   } catch {
     getLogger().warn({ s: "state", taskDir }, "failed to read task name");
+    return dirSlugName(taskDir);
+  }
+}
+
+// Same as taskName but reuses an already-loaded TaskState (avoids re-reading
+// state.json per resume-menu entry). The only per-entry disk read is the
+// USER_REQUEST.md fallback, which is unavoidable for generic descriptions.
+export function taskNameFromState(taskDir: string, state: TaskState): string {
+  let desc = state.description ?? "";
+
+  if (["implement", "debug", "brainstorm", "review", "quick"].includes(desc)) {
+    const urPath = join(taskDir, "USER_REQUEST.md");
+    if (existsSync(urPath)) {
+      const content = readFileSync(urPath, "utf-8");
+      const lines = content.split("\n").map((l) => l.trim()).filter((l) => l.length > 0);
+      const firstContent = lines.find((l) => !l.startsWith("#"));
+      if (firstContent) desc = firstContent;
+    }
   }
+
+  if (desc) {
+    desc = desc.replace(/\s+/g, " ").trim();
+    if (desc.length > 60) desc = desc.slice(0, 57) + "...";
+    return desc;
+  }
+  return dirSlugName(taskDir);
+}
+
+function dirSlugName(taskDir: string): string {
+  const dir = basename(taskDir);
+  const idx = dir.indexOf("_");
+  const slug = idx >= 0 ? dir.slice(idx + 1) : dir;
+  return slug.replace(/-/g, " ");
+}
+
+// The task's short id is the leading segment of its dir name (`${id}_${slug}`),
+// where id is a 12-char uuid slice from createTask. Used to disambiguate
+// otherwise-identical resume-menu titles.
+export function taskShortId(taskDir: string): string {
   const dir = basename(taskDir);
-  const match = dir.match(/^\d+_(.+)$/);
-  return match ? match[1].replace(/-/g, " ") : dir;
+  const idPart = dir.split("_", 1)[0] ?? dir;
+  return idPart.slice(0, 6);
 }
 
 export function taskAge(state: TaskState): string {

package/extensions/orchestrator/test-helpers.ts

@@ -9,7 +9,10 @@ export interface MenuExpectation {
     include?: TextMatch[];
     exclude?: TextMatch[];
   };
-  choose: TextMatch | ((options: string[]) => string);
+  // When set, the harness returns a cancel (as askUser/isCancel would on ESC)
+  // instead of choosing an option. `choose` is ignored in that case.
+  cancel?: "user" | "timeout" | "signal";
+  choose?: TextMatch | ((options: string[]) => string);
 }
 
 export interface MenuTranscriptEntry {
@@ -21,7 +24,7 @@ export interface MenuTranscriptEntry {
 export interface AskUserHarness {
   transcript: MenuTranscriptEntry[];
   expect(step: MenuExpectation): AskUserHarness;
-  handle(opts: any): Promise<{ kind: "selection"; selections: [string] }>;
+  handle(opts: any): Promise<{ kind: "selection"; selections: [string] } | { __cancel: true; reason: "user" | "timeout" | "signal" }>;
   assertDone(): void;
 }
 
@@ -123,6 +126,15 @@ export function createAskUserHarness(): AskUserHarness {
         }
       }
 
+      if (expected.cancel) {
+        transcript.push({ question, options, chosen: `<cancel:${expected.cancel}>` });
+        return { __cancel: true, reason: expected.cancel };
+      }
+
+      if (expected.choose === undefined) {
+        throw new Error(`Menu expectation is missing a chooser\n${renderMenu(question, options)}`);
+      }
+
       let chosen: string;
       if (typeof expected.choose === "function") {
         const maybeChoice = (expected.choose as (options: string[]) => unknown)(titles);