pi-subagents-lite 1.0.2 → 1.2.0

package/src/menus.ts

@@ -2,27 +2,51 @@
  * menus.ts — /agents command menu system.
  *
  * All menu-related functions extracted from index.ts.
- * Imports shared state (config, manager, piInstance) from index.ts.
+ * Imports shared state (config, manager, piInstance) from state.ts.
  */
 
 import type { ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
-import { getAgentConfig, getAvailableTypes, getAllTypes } from "./agent-types.js";
-import type { AgentRecord } from "./types.js";
-import { SHORT_ID_LENGTH } from "./types.js";
+import { getAgentConfig, getAvailableTypes, getAllTypes, resolveType, discoverNewAgents } from "./agent-types.js";
+import type { AgentRecord, ThinkingLevel } from "./types.js";
+import { SHORT_ID_LENGTH, CONFIG_AGENT_NON_MODEL_KEYS } from "./types.js";
+import type { SpawnOptions } from "./agent-manager.js";
 import { ModelSelectorDialog, type ModelOption } from "./model-selector.js";
 import { ResultViewer, type ResultViewerStats } from "./result-viewer.js";
-import { getDisplayName } from "./ui/agent-widget.js";
+import { getDisplayName } from "./format.js";
 import { buildSnapshotMarkdown } from "./context.js";
 
-import { parseModelKey } from "./utils.js";
+import { parseModelKey, findModelInRegistry } from "./utils.js";
 import {
   __config,
   sessionOverrides,
-  manager,
   piInstance,
-} from "./index.js";
+  sessionCtx,
+  agentActivity,
+  getManager,
+  getWidget,
+} from "./state.js";
 import { resolveModel } from "./model-precedence.js";
-import { saveConfigAtomic, DEFAULT_CONFIG } from "./config-io.js";
+import { createActivityTracker, backgroundAgentIds } from "./tool-execution.js";
+import {
+  setModelOverride,
+  setDefaultModel,
+  clearModelOverride,
+  clearAllModelOverrides,
+  setForceBackground,
+  setShowCost,
+  setGraceTurns,
+  setWidgetCompact,
+  setWidgetMaxLines,
+  setWidgetMaxLinesCompact,
+  setWidgetShortcut,
+  setAgent,
+  setConcurrencyDefault,
+  setConcurrencyProvider,
+  setConcurrencyModel,
+  removeConcurrencyProvider,
+  removeConcurrencyModel,
+  resetConcurrency,
+} from "./config-mutator.js";
 
 // ============================================================================
 // Helpers
@@ -113,45 +137,50 @@ async function applyModelOverride(
 }
 
 /**
- * Persist concurrency config to disk and apply to the running manager.
- */
-function applyConcurrencyConfig(): void {
-  saveConfigAtomic(__config);
-  manager?.setConcurrency(__config.concurrency);
-}
-
-/**
- * Parse a concurrency input: prompt, validate (integer ≥ 1), return parsed value or undefined.
+ * Prompt for numeric input, validate (integer ≥ min), return parsed value or undefined.
+ * Returns undefined if the user cancels or the value is invalid.
  */
-async function parseConcurrencyInput(
+async function parseNumericInput(
   ctx: ExtensionCommandContext,
   label: string,
   initialValue: string,
+  min: number,
+  minLabel: string,
 ): Promise<number | undefined> {
   const input = await ctx.ui.input(label, initialValue);
   if (input === undefined) return undefined;
   const parsed = parseInt(input.trim(), 10);
-  if (isNaN(parsed) || parsed < 1) {
-    ctx.ui.notify("Invalid value — must be a number ≥ 1", "error");
+  if (isNaN(parsed) || parsed < min) {
+    ctx.ui.notify(`Invalid value — must be a number ${minLabel}`, "error");
     return undefined;
   }
   return parsed;
 }
 
 /**
- * Prompt for a concurrency value, validate, save and apply.
- * Used for editing an existing concurrency limit.
+ * Parse a concurrency input: prompt, validate (integer ≥ 1), return parsed value or undefined.
+ */
+async function parseConcurrencyInput(
+  ctx: ExtensionCommandContext,
+  label: string,
+  initialValue: string,
+): Promise<number | undefined> {
+  return parseNumericInput(ctx, label, initialValue, 1, "≥ 1");
+}
+
+/**
+ * Prompt for a concurrency value, validate, and apply via setter.
+ * The setter handles save + sync internally.
  */
 async function promptConcurrencyInput(
   ctx: ExtensionCommandContext,
   label: string,
   currentValue: number,
-  apply: (value: number) => void,
+  setter: (value: number) => void,
 ): Promise<void> {
   const parsed = await parseConcurrencyInput(ctx, label, String(currentValue));
   if (parsed === undefined) return;
-  apply(parsed);
-  applyConcurrencyConfig();
+  setter(parsed);
   ctx.ui.notify(
     `${label.replace("Concurrency slots for ", "")} concurrency set to ${parsed}`,
     "info",
@@ -160,16 +189,16 @@ async function promptConcurrencyInput(
 
 /**
  * Prompt to add a new concurrency limit for a named entity.
+ * Calls the setter which handles save + sync internally.
  */
 async function promptAddConcurrencyLimit(
   ctx: ExtensionCommandContext,
   label: string,
-  apply: (key: string, value: number) => void,
+  setter: (key: string, value: number) => void,
 ): Promise<void> {
   const parsed = await parseConcurrencyInput(ctx, "Concurrency slots", "1");
   if (parsed === undefined) return;
-  apply(label, parsed);
-  applyConcurrencyConfig();
+  setter(label, parsed);
   ctx.ui.notify(`${label} concurrency set to ${parsed}`, "info");
 }
 
@@ -218,6 +247,96 @@ async function runMenuLoop(
   }
 }
 
+// ============================================================================
+// Worktree picker helpers
+// ============================================================================
+
+/** Timeout for git worktree list command (ms). */
+const WORKTREE_LIST_TIMEOUT_MS = 5000;
+
+/** Max display length for a worktree path before truncation. */
+const WORKTREE_PATH_TRUNCATE_LEN = 60;
+
+interface WorktreeEntry {
+  path: string;
+  branch: string | null;
+  isDetached: boolean;
+}
+
+/**
+ * Parse `git worktree list --porcelain` output into structured entries.
+ *
+ * Format (one block per worktree, separated by blank lines):
+ *   worktree /path/to/worktree
+ *   HEAD <sha>
+ *   branch refs/heads/<name>   (or: (detached))
+ */
+function parseWorktreeList(output: string): WorktreeEntry[] {
+  const entries: WorktreeEntry[] = [];
+  const blocks = output.split(/\n\n+/);
+  for (const block of blocks) {
+    if (!block.trim()) continue;
+    const lines = block.split("\n");
+    let path = "";
+    let branch: string | null = null;
+    let isDetached = false;
+    for (const line of lines) {
+      if (line.startsWith("worktree ")) {
+        path = line.slice("worktree ".length);
+      } else if (line.startsWith("branch refs/heads/")) {
+        branch = line.slice("branch refs/heads/".length);
+      } else if (line === "detached") {
+        isDetached = true;
+      }
+    }
+    if (path) {
+      entries.push({ path, branch, isDetached });
+    }
+  }
+  return entries;
+}
+
+/** Truncate a path for display, keeping the tail. */
+function truncatePath(p: string): string {
+  if (p.length <= WORKTREE_PATH_TRUNCATE_LEN) return p;
+  return "..." + p.slice(p.length - WORKTREE_PATH_TRUNCATE_LEN + 3);
+}
+
+/**
+ * Fetch worktrees via `git worktree list --porcelain`.
+ * Returns null if git is unavailable or the command fails.
+ */
+async function listWorktrees(cwd: string): Promise<WorktreeEntry[] | null> {
+  try {
+    const result = await piInstance.exec(
+      "git",
+      ["worktree", "list", "--porcelain"],
+      { cwd, timeout: WORKTREE_LIST_TIMEOUT_MS },
+    );
+    if (result.code !== 0) return null;
+    return parseWorktreeList(result.stdout);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Check whether a directory is inside a git repository.
+ * Uses `git rev-parse --git-common-dir` — the same strategy as the worktree validator.
+ */
+async function isInGitRepo(cwd: string): Promise<boolean> {
+  try {
+    const result = await piInstance.exec(
+      "git",
+      ["rev-parse", "--git-common-dir"],
+      { cwd, timeout: WORKTREE_LIST_TIMEOUT_MS },
+    );
+    return result.code === 0 && result.stdout.trim() !== "";
+  } catch {
+    return false;
+  }
+}
+
 // ============================================================================
 // /agents command handler
 // ============================================================================
@@ -246,13 +365,12 @@ export async function showModelSettingsMenu(
 
       // Handle "clear" — remove all overrides (session + config) and save
       if (mode === "clear") {
-        delete __config.agent[targetKey];
+        clearModelOverride(targetKey);
         if (targetKey !== "default") {
           delete sessionOverrides[targetKey];
         } else {
           sessionOverrides.default = null;
         }
-        saveConfigAtomic(__config);
         ctx.ui.notify(`${label} overrides cleared`, "info");
         return;
       }
@@ -264,12 +382,9 @@ export async function showModelSettingsMenu(
         isSession
           ? (chosen) => { sessionOverrides[targetKey] = chosen; }
           : (chosen) => {
-              __config.agent[targetKey] = chosen;
+              setModelOverride(targetKey, chosen);
             },
       );
-      if (!isSession) {
-        saveConfigAtomic(__config);
-      }
     };
 
     // Global default — show session value if present
@@ -293,31 +408,28 @@ export async function showModelSettingsMenu(
       : "Force background · OFF";
     items.push(forceBgLabel);
     actions.push(async () => {
-      __config.agent.forceBackground = !__config.agent.forceBackground;
-      saveConfigAtomic(__config);
+      setForceBackground(!__config.agent.forceBackground);
       ctx.ui.notify(
         `Force background ${__config.agent.forceBackground ? "ON" : "OFF"}`,
         "info",
       );
     });
 
+    // Cost display toggle
+    const showCost = __config.agent.showCost === true; // default false
+    items.push(`Cost display · ${showCost ? "ON" : "OFF"}`);
+    actions.push(async () => {
+      setShowCost(!showCost);
+      ctx.ui.notify(`Cost display ${showCost ? "OFF" : "ON"}`, "info");
+    });
+
     // Grace turns setting
     const graceTurns = __config.agent.graceTurns ?? 6;
     items.push(`Grace turns · ${graceTurns}`);
     actions.push(async () => {
-      const input = await ctx.ui.input("Grace turns (≥ 0)", String(graceTurns));
-      if (input === undefined) return;
-      const parsed = parseInt(input.trim(), 10);
-      if (isNaN(parsed)) {
-        ctx.ui.notify("Invalid value — must be a number", "error");
-        return;
-      }
-      if (parsed < 0) {
-        ctx.ui.notify("Invalid value — must be ≥ 0", "error");
-        return;
-      }
-      __config.agent.graceTurns = parsed;
-      saveConfigAtomic(__config);
+      const parsed = await parseNumericInput(ctx, "Grace turns (≥ 0)", String(graceTurns), 0, "≥ 0");
+      if (parsed === undefined) return;
+      setGraceTurns(parsed);
       ctx.ui.notify(`Grace turns set to ${parsed}`, "info");
     });
 
@@ -395,21 +507,13 @@ export async function showModelSettingsMenu(
     items.push("Clear all overrides");
     actions.push(async () => {
       const hasOverrides = Object.entries(__config.agent).some(
-        ([k, v]) => k !== "default" && k !== "forceBackground" && k !== "graceTurns" && v != null,
+        ([k, v]) => !CONFIG_AGENT_NON_MODEL_KEYS.includes(k) && v != null,
       );
       if (!hasOverrides && __config.agent.default === null) {
         ctx.ui.notify("No overrides to clear", "info");
         return;
       }
-      const preserved: Record<string, unknown> = {
-        default: __config.agent.default,
-        forceBackground: __config.agent.forceBackground,
-      };
-      if (__config.agent.graceTurns != null) {
-        preserved.graceTurns = __config.agent.graceTurns;
-      }
-      __config.agent = preserved as typeof __config.agent;
-      saveConfigAtomic(__config);
+      clearAllModelOverrides();
       ctx.ui.notify("All model overrides cleared", "info");
     });
 
@@ -417,33 +521,340 @@ export async function showModelSettingsMenu(
   });
 }
 
-export async function showAgentsMainMenu(
+/** Map menu choice to handler. Matches by number prefix or first word. */
+function matchMenuChoice(
+  choice: string,
+  handlers: Record<string, () => Promise<void>>,
+): (() => Promise<void>) | undefined {
+  // Try number prefix first (e.g., "1." from "1. Running agents")
+  const numMatch = choice.match(/^(\d+)/);
+  if (numMatch) return handlers[numMatch[1]];
+  // Fall back to first word
+  const key = choice.split(" ")[0].toLowerCase();
+  return handlers[key];
+}
+
+// ============================================================================
+// Spawn agent menu
+// ============================================================================
+
+const THINKING_LEVELS: ThinkingLevel[] = ["off", "minimal", "low", "medium", "high", "xhigh"];
+
+/**
+ * Show the spawn agent flow: type selection → prompt → options sub-menu → spawn.
+ * Escape at any step aborts the flow and returns to the main menu.
+ */
+export async function showSpawnAgentMenu(
+  ctx: ExtensionCommandContext,
+  modelOptions: string[],
+): Promise<void> {
+  // Step 1: Type selection loop (unknown type → error → retry)
+  let selectedType: string;
+  while (true) {
+    const types = getAvailableTypes();
+    if (types.length === 0) {
+      ctx.ui.notify("No agent types available", "error");
+      return;
+    }
+    const type = await ctx.ui.select("Select agent type", types);
+    if (type === undefined) return; // Escape → main menu
+
+    const config = getAgentConfig(type);
+    if (!config) {
+      ctx.ui.notify(`Unknown agent type: ${type}`, "error");
+      continue; // Loop back to type selection
+    }
+    selectedType = type;
+    break;
+  }
+
+  const agentConfig = getAgentConfig(selectedType)!;
+
+  // Step 2: Prompt entry loop (empty prompt → error → retry)
+  let prompt: string;
+  while (true) {
+    const input = await ctx.ui.input("Agent prompt");
+    if (input === undefined) return; // Escape → main menu
+
+    if (!input.trim()) {
+      ctx.ui.notify("Prompt cannot be empty", "error");
+      continue; // Loop back to prompt input
+    }
+    prompt = input.trim();
+    break;
+  }
+
+  // Step 3: Options sub-menu with spawn action
+  const autoDescription = prompt.length > 50 ? prompt.slice(0, 50) : prompt;
+  let description = autoDescription;
+
+  // Check if parent's cwd is inside a git repo (for worktree picker visibility)
+  const parentCwd = sessionCtx?.cwd ?? "";
+  const inGitRepo = parentCwd ? await isInGitRepo(parentCwd) : false;
+
+  // Worktree picker state
+  let currentWorktreePath: string | undefined;
+  let currentWorktreeLabel = "Inherits parent cwd";
+
+  // Pre-fill model from precedence chain
+  const parentModelId = sessionCtx?.model
+    ? `${sessionCtx.model.provider}/${sessionCtx.model.id}`
+    : "";
+  const effectiveModelStr = resolveModel({
+    subagentType: selectedType,
+    agentConfig,
+    config: __config,
+    parentModelId,
+    sessionOverrides,
+  });
+  let currentModelStr = effectiveModelStr || ""; // "" means inherit parent
+  let currentThinking: ThinkingLevel | undefined = agentConfig.thinking;
+  let currentMaxTurns: number | undefined = agentConfig.maxTurns;
+  let currentGraceTurns: number | undefined = __config.agent.graceTurns ?? 6;
+  let currentBackground: boolean = __config.agent.forceBackground ?? false;
+
+  while (true) {
+    const displayModel = currentModelStr || "(inherits parent)";
+    const displayThinking = currentThinking ?? "inherit";
+    const displayMaxTurns = currentMaxTurns != null ? String(currentMaxTurns) : "unlimited";
+    const displayGraceTurns = String(currentGraceTurns ?? 6);
+    const displayBackground = currentBackground ? "ON" : "OFF";
+
+    const items = [
+      "Spawn",
+      "",
+      `Model · ${displayModel}`,
+      `Background · ${displayBackground}`,
+      `Thinking · ${displayThinking}`,
+      `Max turns · ${displayMaxTurns}`,
+      `Grace turns · ${displayGraceTurns}`,
+      `Description · ${description}`,
+    ];
+
+    if (inGitRepo) {
+      items.push(`Worktree · ${currentWorktreeLabel}`);
+    };
+
+    const choice = await ctx.ui.select("Spawn Options", items);
+    if (choice === undefined) return; // Escape → main menu
+
+    if (choice === "Spawn") {
+      // Resolve model string to Model object
+      let model: ReturnType<typeof findModelInRegistry> = undefined;
+      let modelKey: string | undefined;
+
+      if (currentModelStr) {
+        const registry = sessionCtx?.modelRegistry ?? ctx.modelRegistry;
+        model = findModelInRegistry(currentModelStr, registry, undefined);
+        if (!model) {
+          ctx.ui.notify(`Model not found: ${currentModelStr}`, "error");
+          continue; // Return to options sub-menu
+        }
+        modelKey = `${model.provider}/${model.id}`;
+      }
+
+      // Discover worktree-local agent types before spawn
+      if (currentWorktreePath) {
+        await discoverNewAgents(`${currentWorktreePath}/.pi/agents`);
+      }
+      // Resolve type (may have been discovered from worktree)
+      const resolvedType = resolveType(selectedType) ?? selectedType;
+
+      const spawnOptions: SpawnOptions = {
+        description,
+        model,
+        maxTurns: currentMaxTurns,
+        thinkingLevel: currentThinking,
+        isBackground: currentBackground,
+        modelKey,
+        invocation: {
+          modelName: model?.id,
+          thinking: currentThinking,
+          maxTurns: currentMaxTurns,
+          runInBackground: currentBackground,
+        },
+        graceTurns: currentGraceTurns,
+        worktreePath: currentWorktreePath,
+        worktreeLabel: currentWorktreePath ? currentWorktreeLabel : undefined,
+      };
+
+      const { state: activityState, callbacks } = createActivityTracker(currentMaxTurns);
+
+      let agentId: string;
+      try {
+        agentId = getManager().spawn(piInstance, sessionCtx, resolvedType, prompt, {
+          ...spawnOptions,
+          ...callbacks,
+        });
+      } catch (err) {
+        ctx.ui.notify(
+          `Spawn failed: ${err instanceof Error ? err.message : String(err)}`,
+          "error",
+        );
+        return; // Return to main menu
+      }
+
+      // Wire activity tracking for widget
+      agentActivity.set(agentId, activityState);
+      // Set UI context so widget can render (same as tool_execution_start handler)
+      const widget = getWidget();
+      if (widget) {
+        widget.setUICtx(ctx.ui as unknown as import("./ui/agent-widget.js").UICtx);
+        widget.ensureTimer();
+        widget.update();
+      }
+
+      if (currentBackground) {
+        backgroundAgentIds.add(agentId);
+        return; // Background: return to main menu immediately
+      }
+
+      // Foreground: block until completion
+      const fgRecord = getManager().getRecord(agentId);
+      if (fgRecord?.execution?.promise) {
+        await fgRecord.execution.promise;
+      }
+
+      agentActivity.delete(agentId);
+      getWidget()?.markFinished(agentId);
+      getWidget()?.update();
+
+      return; // Return to main menu
+    }
+
+    // Handle option changes
+    if (choice.startsWith("Description")) {
+      const input = await ctx.ui.input("Description", description);
+      if (input !== undefined && input.trim()) {
+        description = input.trim();
+      }
+    } else if (choice.startsWith("Model")) {
+      const chosen = await promptModelSelection(
+        ctx, modelOptions, currentModelStr || "(inherits parent)",
+      );
+      if (chosen !== null) {
+        currentModelStr = chosen === "(inherits parent)" ? "" : chosen;
+      }
+    } else if (choice.startsWith("Thinking")) {
+      const allLevels = [...THINKING_LEVELS, "inherit"];
+      const chosen = await ctx.ui.select("Thinking level", allLevels);
+      if (chosen !== undefined) {
+        currentThinking = chosen === "inherit" ? undefined : (chosen as ThinkingLevel);
+      }
+    } else if (choice.startsWith("Max turns")) {
+      const initial = currentMaxTurns != null ? String(currentMaxTurns) : "unlimited";
+      const input = await ctx.ui.input("Max turns (number or 'unlimited')", initial);
+      if (input !== undefined) {
+        const trimmed = input.trim().toLowerCase();
+        if (trimmed === "unlimited" || trimmed === "") {
+          currentMaxTurns = undefined;
+        } else {
+          const parsed = parseInt(trimmed, 10);
+          if (isNaN(parsed) || parsed < 1) {
+            ctx.ui.notify("Invalid value — must be a number ≥ 1 or 'unlimited'", "error");
+          } else {
+            currentMaxTurns = parsed;
+          }
+        }
+      }
+    } else if (choice.startsWith("Grace turns")) {
+      const parsed = await parseNumericInput(ctx, "Grace turns (≥ 0)", String(currentGraceTurns ?? 6), 0, "≥ 0");
+      if (parsed !== undefined) currentGraceTurns = parsed;
+    } else if (choice.startsWith("Background")) {
+      currentBackground = !currentBackground;
+    } else if (choice.startsWith("Worktree") && inGitRepo) {
+      // Open worktree picker
+      const worktrees = await listWorktrees(parentCwd);
+      if (!worktrees || worktrees.length === 0) {
+        ctx.ui.notify(
+          "No worktrees found or git worktree list unavailable",
+          "error",
+        );
+        continue; // Return to options sub-menu
+      }
+
+      const pickerItems = [
+        "Inherits parent cwd",
+        ...worktrees.map(wt => {
+          const branchLabel = wt.isDetached ? "detached" : (wt.branch ?? "detached");
+          const truncPath = truncatePath(wt.path);
+          return `${branchLabel}  ·  ${truncPath}`;
+        }),
+      ];
+
+      const picked = await ctx.ui.select("Select worktree", pickerItems);
+      if (picked === undefined) continue; // Escape → return to options sub-menu
+
+      if (picked === "Inherits parent cwd") {
+        currentWorktreePath = undefined;
+        currentWorktreeLabel = "Inherits parent cwd";
+      } else {
+        // Find the matching worktree by index (offset by "Inherits parent cwd")
+        const idx = pickerItems.indexOf(picked) - 1;
+        if (idx >= 0 && idx < worktrees.length) {
+          const wt = worktrees[idx];
+          currentWorktreePath = wt.path;
+          currentWorktreeLabel = wt.branch ?? "detached";
+        }
+      }
+    }
+  }
+}
+
+export async function showSettingsMenu(
   ctx: ExtensionCommandContext,
   modelOptions: string[],
 ): Promise<void> {
   const menuItems = [
     "1. Model settings — Set global default and per-type model overrides",
     "2. Concurrency settings — Set per-model slot limits",
-    "3. Running agents — List running/queued agents",
+    "3. Widget settings — Configure widget display options",
+    "",
+    "Back",
+  ];
+
+  const handlers: Record<string, () => Promise<void>> = {
+    "1": () => showModelSettingsMenu(ctx, modelOptions),
+    "2": () => showConcurrencySettingsMenu(ctx, modelOptions),
+    "3": () => showWidgetSettingsMenu(ctx),
+  };
+
+  while (true) {
+    const choice = await ctx.ui.select("Settings", menuItems);
+    if (choice === undefined || choice === "Back") return;
+
+    const action = matchMenuChoice(choice, handlers);
+    if (action) await action();
+  }
+}
+
+export async function showAgentsMainMenu(
+  ctx: ExtensionCommandContext,
+  modelOptions: string[],
+): Promise<void> {
+  const menuItems = [
+    "1. Running agents — List running/queued agents",
+    "2. Spawn agent — Manually spawn a new agent",
+    "3. Settings — Model, concurrency, and widget settings",
     "4. Debug — Agent types, briefing, diagnostics",
     "",
     "Press Escape to close",
   ];
 
+  const handlers: Record<string, () => Promise<void>> = {
+    "1": () => showRunningAgentsMenu(ctx),
+    "2": () => showSpawnAgentMenu(ctx, modelOptions),
+    "3": () => showSettingsMenu(ctx, modelOptions),
+    "4": () => showDebugMenu(ctx),
+  };
+
   // Loop so sub-menus navigate back to root; only Escape at root closes
   while (true) {
     const choice = await ctx.ui.select("Subagents Management", menuItems);
     if (choice === undefined || choice === "Press Escape to close") return;
 
-    if (choice.startsWith("1.")) {
-      await showModelSettingsMenu(ctx, modelOptions);
-    } else if (choice.startsWith("2.")) {
-      await showConcurrencySettingsMenu(ctx, modelOptions);
-    } else if (choice.startsWith("3.")) {
-      await showRunningAgentsMenu(ctx);
-    } else if (choice.startsWith("4.")) {
-      await showDebugMenu(ctx);
-    }
+    const action = matchMenuChoice(choice, handlers);
+    if (action) await action();
   }
 }
 
@@ -453,18 +864,65 @@ async function showDebugMenu(ctx: ExtensionCommandContext): Promise<void> {
     "2. Agent briefing — Send agent types/capabilities info to LLM (Optional, if having issues)",
   ];
 
+  const handlers: Record<string, () => Promise<void>> = {
+    "1": () => showAgentTypes(ctx),
+    "2": () => handleAgentBriefing(ctx),
+  };
+
   while (true) {
     const choice = await ctx.ui.select("Debug", menuItems);
     if (choice === undefined) return;
 
-    if (choice.startsWith("1.")) {
-      await showAgentTypes(ctx);
-    } else if (choice.startsWith("2.")) {
-      await handleAgentBriefing(ctx);
-    }
+    const action = matchMenuChoice(choice, handlers);
+    if (action) await action();
   }
 }
 
+export async function showWidgetSettingsMenu(ctx: ExtensionCommandContext): Promise<void> {
+  return runMenuLoop(ctx, "Widget Settings", () => {
+    const items: string[] = [];
+    const actions: Array<() => Promise<void>> = [];
+
+    // Force compact mode toggle
+    const isForceCompact = __config.agent.widgetCompact === true;
+    items.push(`Force compact mode · ${isForceCompact ? "ON" : "OFF"}`);
+    actions.push(async () => {
+      setWidgetCompact(!isForceCompact);
+      ctx.ui.notify(`Force compact mode ${__config.agent.widgetCompact ? "ON" : "OFF"}`, "info");
+    });
+
+    // Max lines (full mode)
+    const maxLines = __config.agent.widgetMaxLines ?? 12;
+    items.push(`Max lines (full) · ${maxLines}`);
+    actions.push(async () => {
+      const parsed = await parseNumericInput(ctx, "Max lines (full mode, ≥ 2)", String(maxLines), 2, "≥ 2");
+      if (parsed === undefined) return;
+      setWidgetMaxLines(parsed);
+      ctx.ui.notify(`Max lines (full) set to ${parsed}`, "info");
+    });
+
+    // Max lines (compact mode)
+    const maxLinesCompact = __config.agent.widgetMaxLinesCompact ?? Math.floor(maxLines / 2);
+    items.push(`Max lines (compact) · ${maxLinesCompact}`);
+    actions.push(async () => {
+      const parsed = await parseNumericInput(ctx, "Max lines (compact mode, ≥ 1)", String(maxLinesCompact), 1, "≥ 1");
+      if (parsed === undefined) return;
+      setWidgetMaxLinesCompact(parsed);
+      ctx.ui.notify(`Max lines (compact) set to ${parsed}`, "info");
+    });
+
+    // Ctrl+o shortcut toggle
+    const shortcutEnabled = __config.agent.widgetShortcut === true;
+    items.push(`Ctrl+o shortcut · ${shortcutEnabled ? "ON" : "OFF"}`);
+    actions.push(async () => {
+      setWidgetShortcut(!shortcutEnabled);
+      ctx.ui.notify(`Ctrl+o shortcut ${__config.agent.widgetShortcut ? "ON" : "OFF"}`, "info");
+    });
+
+    return { items, actions };
+  });
+}
+
 async function handleAgentBriefing(ctx: ExtensionCommandContext): Promise<void> {
   const types = getAvailableTypes();
   const agents = types.map((t) => ({ name: t, config: getAgentConfig(t) }));
@@ -501,6 +959,7 @@ async function handleAgentBriefing(ctx: ExtensionCommandContext): Promise<void>
   lines.push("| `agent` | Which agent type to use (default: general-purpose) |");
   lines.push("| `thinking` | Optional thinking mode override (e.g., `off`, `minimal`, `low`, `medium`, `high`, `xhigh`) |");
   lines.push("| `run_in_background` | When `true`, result is auto-delivered — do NOT poll. Continue working while waiting. |");
+  lines.push("| `worktree_path` | Optional path to a git worktree of the parent's repo. See below for details. |");
   lines.push("");
 
   // Usage guidelines
@@ -508,6 +967,15 @@ async function handleAgentBriefing(ctx: ExtensionCommandContext): Promise<void>
   lines.push("- Agents start fresh with their config — they do NOT inherit the parent conversation");
   lines.push("- For parallel tasks, spawn multiple `run_in_background: true` agents in one turn");
   lines.push("  → Results are auto-delivered — do NOT poll, the result will arrive when ready");
+  lines.push("");
+  lines.push("## `worktree_path` Parameter\n");
+  lines.push("Use `worktree_path` to run a subagent in a different git worktree of the parent's repository.");
+  lines.push("");
+  lines.push("- **Optional.** Omit to run the subagent in the parent's working directory (default behavior).");
+  lines.push("- **Must be a path** inside a git worktree of the parent's repo, including the main checkout. Not a different repo, not a non-git directory.");
+  lines.push("- **Relative paths** are resolved against the parent's working directory.");
+  lines.push("- **On failure** the validator returns a specific reason (e.g., 'not a worktree of the parent's repository', 'path does not exist') — use this to self-correct.");
+  lines.push("- **Agent type discovery:** The worktree's `.pi/agents/` directory is scanned for agent types when this param is set, so worktree-local types become available to that spawn.");
   piInstance.sendUserMessage(lines.join("\n"));
   ctx.ui.notify("Agent briefing sent to LLM", "info");
 }
@@ -515,6 +983,7 @@ async function handleAgentBriefing(ctx: ExtensionCommandContext): Promise<void>
 /**
  * Build a sub-menu for a single per-provider or per-model entry:
  * "Edit limit" to change the value, or "Remove limit" to delete it.
+ * Callers pass setter callbacks that handle save + sync internally.
  */
 async function editOrRemoveConcurrencyEntry(
   ctx: ExtensionCommandContext,
@@ -522,8 +991,8 @@ async function editOrRemoveConcurrencyEntry(
   entityType: "provider" | "model",
   entityKey: string,
   currentValue: number,
-  applyUpdate: (value: number) => void,
-  applyRemove: () => void,
+  setEntry: (key: string, value: number) => void,
+  removeEntry: () => void,
 ): Promise<void> {
   await runMenu(ctx, `${entityKey} concurrency`, [
     "Edit limit",
@@ -531,13 +1000,12 @@ async function editOrRemoveConcurrencyEntry(
   ], [
     async () => {
       await promptConcurrencyInput(
-        ctx, label, currentValue,
-        applyUpdate,
+        ctx, entityKey, currentValue,
+        (value) => setEntry(entityKey, value),
       );
     },
     async () => {
-      applyRemove();
-      applyConcurrencyConfig();
+      removeEntry();
       ctx.ui.notify(
         `Removed per-${entityType} limit for ${entityKey}`,
         "info",
@@ -561,15 +1029,14 @@ export async function showConcurrencySettingsMenu(
     actions.push(async () => {
       await promptConcurrencyInput(
         ctx, "Default limit", __config.concurrency.default,
-        (value) => { __config.concurrency.default = value; },
+        (value) => setConcurrencyDefault(value),
       );
     });
 
     // Reset all to defaults
     items.push("Reset all to defaults");
     actions.push(async () => {
-      __config.concurrency = { ...DEFAULT_CONFIG.concurrency };
-      applyConcurrencyConfig();
+      resetConcurrency();
       ctx.ui.notify("Concurrency reset to defaults", "info");
     });
 
@@ -592,16 +1059,8 @@ export async function showConcurrencySettingsMenu(
             "provider",
             provider,
             limit,
-            (value) => {
-              const current = __config.concurrency.providers ?? {};
-              __config.concurrency.providers = { ...current, [provider]: value };
-            },
-            () => {
-              const providers = __config.concurrency.providers;
-              if (providers) {
-                delete providers[provider];
-              }
-            },
+            (key, value) => setConcurrencyProvider(key, value),
+            () => removeConcurrencyProvider(provider),
           );
         });
       }
@@ -614,10 +1073,7 @@ export async function showConcurrencySettingsMenu(
       if (provider === undefined) return;
       await promptAddConcurrencyLimit(
         ctx, provider,
-        (key, value) => {
-          const current = __config.concurrency.providers ?? {};
-          __config.concurrency.providers = { ...current, [key]: value };
-        },
+        (key, value) => setConcurrencyProvider(key, value),
       );
     });
 
@@ -640,16 +1096,8 @@ export async function showConcurrencySettingsMenu(
             "model",
             modelKey,
             limit,
-            (value) => {
-              const current = __config.concurrency.models ?? {};
-              __config.concurrency.models = { ...current, [modelKey]: value };
-            },
-            () => {
-              const models = __config.concurrency.models;
-              if (models) {
-                delete models[modelKey];
-              }
-            },
+            (key, value) => setConcurrencyModel(key, value),
+            () => removeConcurrencyModel(modelKey),
           );
         });
       }
@@ -664,10 +1112,7 @@ export async function showConcurrencySettingsMenu(
       if (modelKey === null) return;
       await promptAddConcurrencyLimit(
         ctx, modelKey.trim(),
-        (key, value) => {
-          const current = __config.concurrency.models ?? {};
-          __config.concurrency.models = { ...current, [key]: value };
-        },
+        (key, value) => setConcurrencyModel(key, value),
       );
     });
 
@@ -678,27 +1123,31 @@ export async function showConcurrencySettingsMenu(
 async function showRunningAgentsMenu(
   ctx: ExtensionCommandContext,
 ): Promise<void> {
-  const records = manager?.listAgents() ?? [];
+  const records = getManager()?.listAgents() ?? [];
   if (records.length === 0) {
     ctx.ui.notify("No agents have been spawned this session", "info");
     return;
   }
 
   return runMenuLoop(ctx, "Running Agents", () => {
-    const records = manager?.listAgents() ?? [];
-    const running = records.filter((r) => r.status === "running" || r.status === "queued");
+    const records = getManager()?.listAgents() ?? [];
+    const running = records.filter((r) => r.lifecycle.status === "running" || r.lifecycle.status === "queued");
 
     const items: string[] = [];
     const actions: Array<() => Promise<void>> = [];
 
     for (const record of records) {
-      const elapsed = Math.round((Date.now() - record.startedAt) / 1000);
-      const statusIcon = record.status === "running" ? "▶" :
-        record.status === "completed" ? "✓" :
-        record.status === "queued" ? "⏳" :
-        record.status === "error" ? "✗" : "•";
+      const elapsed = Math.round((Date.now() - record.lifecycle.startedAt) / 1000);
+      const statusIcon = record.lifecycle.status === "running" ? "▶" :
+        record.lifecycle.status === "completed" ? "✓" :
+        record.lifecycle.status === "queued" ? "⏳" :
+        record.lifecycle.status === "error" ? "✗" : "•";
+      const headline = record.display.description
+        ? (record.display.description.length > 50 ? record.display.description.slice(0, 47) + "..." : record.display.description)
+        : "";
+      const suffix = headline ? ` — ${headline}` : "";
       items.push(
-        `${statusIcon} ${record.id.slice(0, SHORT_ID_LENGTH)}  ${record.type}  ${record.status}  ${elapsed}s`,
+        `${statusIcon} ${record.id.slice(0, SHORT_ID_LENGTH)}  ${record.display.type}  ${record.lifecycle.status}  ${elapsed}s${suffix}`,
       );
 
       actions.push(async () => {
@@ -715,7 +1164,7 @@ async function showRunningAgentsMenu(
       items.push(`Stop ${running.length} running agent(s)`);
       actions.push(async () => {
         for (const record of running) {
-          manager?.abort(record.id);
+          getManager()?.abort(record.id);
         }
         ctx.ui.notify(`Stopped ${running.length} agent(s)`, "info");
       });
@@ -741,19 +1190,19 @@ async function showResultViewer(
     ? `snapshot \u00b7 ${record.id.slice(0, SHORT_ID_LENGTH)}`
     : "Error";
   const stats: ResultViewerStats = {
-    lifetimeUsage: record.lifetimeUsage,
-    turnCount: record.turnCount,
-    durationMs: (record.completedAt ?? Date.now()) - record.startedAt,
+    lifetimeUsage: record.stats.lifetimeUsage,
+    turnCount: record.stats.turnCount,
+    durationMs: (record.lifecycle.completedAt ?? Date.now()) - record.lifecycle.startedAt,
   };
   const refreshCallback =
-    kind === "snapshot" && record.session
-      ? () => buildSnapshotMarkdown(record.session!.messages)
+    kind === "snapshot" && record.execution.session
+      ? () => buildSnapshotMarkdown(record.execution.session!.messages)
       : undefined;
 
   await ctx.ui.custom<void>(
     (tui, theme, _kb, done) =>
       new ResultViewer(
-        `${getDisplayName(record.type)} · ${titleSuffix}`,
+        `${getDisplayName(record.display.type)} · ${titleSuffix}`,
         text,
         { onClose: () => done(), onRefresh: refreshCallback },
         theme,
@@ -770,16 +1219,16 @@ async function steerAgentById(
   agentId: string,
   ctx: ExtensionCommandContext,
 ): Promise<void> {
-  const record = manager?.getRecord(agentId);
+  const record = getManager()?.getRecord(agentId);
   if (!record) {
     ctx.ui.notify("Agent not found", "error");
     return;
   }
 
-  const message = await ctx.ui.input(`Steer ${record.type}`);
+  const message = await ctx.ui.input(`Steer ${record.display.type}`);
   if (!message?.trim()) return;
 
-  const sent = await manager.steer(agentId, message.trim());
+  const sent = await getManager().steer(agentId, message.trim());
   if (sent) {
     ctx.ui.notify(`Steer sent to ${record.id.slice(0, SHORT_ID_LENGTH)}…`, "info");
   } else {
@@ -798,16 +1247,16 @@ export async function showAgentActions(
   const items: string[] = [];
   const actions: Array<() => Promise<void>> = [];
 
-  const isRunning = record.status === "running" || record.status === "queued";
-  const hasSession = !!record.session;
+  const isRunning = record.lifecycle.status === "running" || record.lifecycle.status === "queued";
+  const hasSession = !!record.execution.session;
   const hasResult = !!record.result && record.result.length > 0;
   const hasError = !!record.error && record.error.length > 0;
 
   // View actions first
-  if (record.status === "running" && hasSession) {
+  if (record.lifecycle.status === "running" && hasSession) {
     items.push("View snapshot");
     actions.push(async () => {
-      const messages = record.session!.messages;
+      const messages = record.execution.session!.messages;
       const markdown = buildSnapshotMarkdown(messages);
       await showResultViewer(ctx, record, "snapshot", markdown);
     });
@@ -836,7 +1285,7 @@ export async function showAgentActions(
 
     items.push("Stop");
     actions.push(async () => {
-      manager?.abort(record.id);
+      getManager()?.abort(record.id);
       ctx.ui.notify(`Stopped ${record.id.slice(0, SHORT_ID_LENGTH)}`, "info");
     });
   }