pi-subagents-lite 1.0.2 → 1.1.0

package/src/menus.ts

@@ -2,27 +2,46 @@
  * 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 { SHORT_ID_LENGTH, CONFIG_AGENT_NON_MODEL_KEYS } from "./types.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 {
   __config,
   sessionOverrides,
-  manager,
   piInstance,
-} from "./index.js";
+  getManager,
+} from "./state.js";
 import { resolveModel } from "./model-precedence.js";
-import { saveConfigAtomic, DEFAULT_CONFIG } from "./config-io.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 +132,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 +184,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");
 }
 
@@ -246,13 +270,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 +287,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 +313,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 +412,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 +426,48 @@ export async function showModelSettingsMenu(
   });
 }
 
+/** 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];
+}
+
 export async function showAgentsMainMenu(
   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",
-    "4. Debug — Agent types, briefing, diagnostics",
+    "1. Running agents — List running/queued agents",
+    "2. Model settings — Set global default and per-type model overrides",
+    "3. Concurrency settings — Set per-model slot limits",
+    "4. Widget settings — Configure widget display options",
+    "5. Debug — Agent types, briefing, diagnostics",
     "",
     "Press Escape to close",
   ];
 
+  const handlers: Record<string, () => Promise<void>> = {
+    "1": () => showRunningAgentsMenu(ctx),
+    "2": () => showModelSettingsMenu(ctx, modelOptions),
+    "3": () => showConcurrencySettingsMenu(ctx, modelOptions),
+    "4": () => showWidgetSettingsMenu(ctx),
+    "5": () => 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 +477,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) }));
@@ -515,6 +586,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 +594,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 +603,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 +632,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 +662,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 +676,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 +699,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 +715,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 +726,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 +767,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 +793,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 +822,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 +850,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 +888,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");
     });
   }

package/src/model-precedence.ts

@@ -18,6 +18,11 @@ export interface SubagentsConfig {
     default: string | null;
     forceBackground: boolean;
     graceTurns?: number;
+    showCost?: boolean;
+    widgetMaxLines?: number;
+    widgetMaxLinesCompact?: number;
+    widgetCompact?: boolean;
+    widgetShortcut?: boolean;
     [agentType: string]: string | null | undefined | boolean | number;
   };
   concurrency: {