@pi-unipi/unipi 2.4.0 → 2.4.2

package/packages/milestone/hooks.ts

@@ -8,7 +8,7 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { MILESTONE_DIRS, safeMtimeMs, tryRead } from "@pi-unipi/core";
+import { MILESTONE_DIRS, UNIPI_EVENTS, safeMtimeMs, tryRead } from "@pi-unipi/core";
 import { parseMilestones, getProgressSummary, updateItemStatus } from "./milestone.js";
 
 /** Track when the session started for diffing modified files */
@@ -167,19 +167,7 @@ export function registerSessionEndHook(pi: ExtensionAPI): void {
     }
   });
 
-  // Listen for WORKFLOW_END events
-  pi.on("input", (event) => {
-    // Check if this is a unipi event emission for WORKFLOW_END
-    // The input event fires for tool calls; we need to detect when
-    // the workflow ends. We'll use the events system instead.
-    return undefined;
-  });
-
-  // Use tool_result to detect workflow end
-  // Actually, we should listen for the UNIPI_EVENTS.WORKFLOW_END via pi.events
-  // But the ExtensionAPI doesn't expose pi.events.on() directly.
-  // Instead, we'll hook into session_shutdown to do a final sync.
-  pi.on("session_shutdown", () => {
+  const syncModifiedDocs = () => {
     const cwd = process.cwd();
     const milestonesPath = path.join(cwd, MILESTONE_DIRS.MILESTONES);
 
@@ -204,5 +192,11 @@ export function registerSessionEndHook(pi: ExtensionAPI): void {
         updateItemStatus(milestonesPath, phase, text, true);
       }
     }
-  });
+  };
+
+  // Workflow emits this once its follow-up agent loop drains.
+  pi.events.on(UNIPI_EVENTS.WORKFLOW_END, syncModifiedDocs);
+
+  // Final fallback for changes made outside a workflow or before event wiring.
+  pi.on("session_shutdown", syncModifiedDocs);
 }

package/packages/milestone/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-unipi/milestone",
-  "version": "2.4.0",
+  "version": "2.4.1",
   "description": "Lifecycle layer for project-level goals — MILESTONES.md tracking, session hooks, auto-sync",
   "type": "module",
   "main": "index.ts",
@@ -29,7 +29,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@pi-unipi/core": "2.4.0"
+    "@pi-unipi/core": "2.4.1"
   },
   "peerDependencies": {
     "@earendil-works/pi-coding-agent": "^0.80.0",

package/packages/notify/README.md

@@ -47,6 +47,8 @@ notify_user({
 })
 ```
 
+An explicit semantic priority overrides configured urgency for that dispatch on platforms that support it: `low`/`normal`/`high` map to Gotify `2`/`5`/`8` and ntfy `2`/`3`/`5`. Native and Telegram have no priority input and ignore it. When omitted, Gotify and ntfy retain their configured numeric priorities.
+
 ## Platforms
 
 ### Native OS

package/packages/notify/events.ts

@@ -7,7 +7,7 @@
 
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { UNIPI_EVENTS, emitEvent } from "@pi-unipi/core";
-import type { NotifyConfig, NotifyPlatform, NotifyDispatchResult } from "./types.js";
+import type { NotifyConfig, NotifyPlatform, NotifyDispatchResult, NotifyPriority } from "./types.js";
 import { loadNtfyConfig } from "./ntfy-config.js";
 import { sendNativeNotification, SuppressedError } from "./platforms/native.js";
 import { sendGotifyNotification } from "./platforms/gotify.js";
@@ -170,7 +170,8 @@ export async function dispatchNotification(
   eventPlatforms: NotifyPlatform[],
   eventType: string,
   config: NotifyConfig,
-  cwd: string
+  cwd: string,
+  priority?: NotifyPriority,
 ): Promise<NotifyDispatchResult> {
   // Resolve ntfy config from project/global ntfy.json
   const ntfyConfig = loadNtfyConfig(cwd);
@@ -194,8 +195,8 @@ export async function dispatchNotification(
   const results = await Promise.all(
     enabledPlatforms.map(async (platform) => {
       try {
-        await sendToPlatform(platform, title, message, config, cwd);
-        return { platform, success: true };
+        const effectivePriority = await sendToPlatform(platform, title, message, config, cwd, priority);
+        return { platform, success: true, ...(effectivePriority === undefined ? {} : { priority: effectivePriority }) };
       } catch (err) {
         // SuppressedError is intentional, not a failure
         if (err instanceof SuppressedError) {
@@ -230,20 +231,29 @@ export async function dispatchNotification(
 }
 
 /** Send to a single platform */
+export function mapNotifyPriority(platform: "gotify" | "ntfy", priority: NotifyPriority): number {
+  const mappings = {
+    gotify: { low: 2, normal: 5, high: 8 },
+    ntfy: { low: 2, normal: 3, high: 5 },
+  } as const;
+  return mappings[platform][priority];
+}
+
 async function sendToPlatform(
   platform: NotifyPlatform,
   title: string,
   message: string,
   config: NotifyConfig,
-  cwd: string
-): Promise<void> {
+  cwd: string,
+  priority?: NotifyPriority,
+): Promise<number | undefined> {
   switch (platform) {
     case "native":
       await sendNativeNotification(title, message, {
         windowsAppId: config.native.windowsAppId,
         suppressWhenFocused: config.native.suppressWhenFocused,
       });
-      break;
+      return undefined;
     case "gotify":
       if (!config.gotify.serverUrl || !config.gotify.appToken) {
         throw new Error("Gotify: serverUrl and appToken are required");
@@ -253,9 +263,9 @@ async function sendToPlatform(
         config.gotify.appToken,
         title,
         message,
-        config.gotify.priority
+        priority ? mapNotifyPriority("gotify", priority) : config.gotify.priority
       );
-      break;
+      return priority ? mapNotifyPriority("gotify", priority) : config.gotify.priority;
     case "telegram":
       if (!config.telegram.botToken || !config.telegram.chatId) {
         throw new Error("Telegram: botToken and chatId are required");
@@ -266,10 +276,10 @@ async function sendToPlatform(
         title,
         message
       );
-      break;
+      return undefined;
     case "ntfy": {
       const ntfyConfig = loadNtfyConfig(cwd);
-      if (!ntfyConfig.enabled) return;
+      if (!ntfyConfig.enabled) return undefined;
       if (!ntfyConfig.serverUrl || !ntfyConfig.topic) {
         throw new Error("ntfy: serverUrl and topic are required");
       }
@@ -278,10 +288,10 @@ async function sendToPlatform(
         ntfyConfig.topic,
         title,
         message,
-        ntfyConfig.priority,
+        priority ? mapNotifyPriority("ntfy", priority) : ntfyConfig.priority,
         ntfyConfig.token
       );
-      break;
+      return priority ? mapNotifyPriority("ntfy", priority) : ntfyConfig.priority;
     }
   }
 }

package/packages/notify/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-unipi/notify",
-  "version": "2.4.0",
+  "version": "2.4.1",
   "description": "Cross-platform notification extension for Pi — native OS, Gotify, and Telegram notifications for agent lifecycle events",
   "type": "module",
   "main": "index.ts",
@@ -34,7 +34,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@pi-unipi/core": "2.4.0",
+    "@pi-unipi/core": "2.4.1",
     "node-notifier": "^10.0.1"
   },
   "peerDependencies": {

package/packages/notify/tools.ts

@@ -8,7 +8,8 @@ import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-a
 import { Type } from "typebox";
 import { NOTIFY_TOOLS } from "@pi-unipi/core";
 import { loadConfig } from "./settings.js";
-import { dispatchNotification } from "./events.js";
+import { dispatchNotification, mapNotifyPriority } from "./events.js";
+import type { NotifyPriority } from "./types.js";
 
 /** Schema for notify_user tool parameters */
 const NotifyUserSchema = Type.Object({
@@ -19,7 +20,6 @@ const NotifyUserSchema = Type.Object({
   priority: Type.Optional(
     Type.String({
       enum: ["low", "normal", "high"],
-      default: "normal",
       description: "Priority level",
     })
   ),
@@ -46,12 +46,12 @@ export function registerNotifyTools(pi: ExtensionAPI): void {
       const {
         message,
         title,
-        priority: _priority,
+        priority,
         platforms,
       } = params as {
         message: string;
         title?: string;
-        priority?: "low" | "normal" | "high";
+        priority?: NotifyPriority;
         platforms?: Array<"native" | "gotify" | "telegram" | "ntfy">;
       };
 
@@ -65,18 +65,27 @@ export function registerNotifyTools(pi: ExtensionAPI): void {
 
       // Fire-and-forget: dispatch in background so the tool doesn't block the agent
       const cwd = process.cwd();
-      dispatchNotification(
+      const dispatchPromise = dispatchNotification(
         pi,
         notifTitle,
         message,
         notifPlatforms,
         "agent_tool",
         config,
-        cwd
-      ).catch(() => {
+        cwd,
+        priority,
+      );
+      void dispatchPromise.catch(() => {
         // Silently ignore — background dispatch failure is non-blocking.
       });
 
+      const priorityByPlatform = priority ? Object.fromEntries(
+        notifPlatforms.flatMap((platform) => {
+          if (platform === "gotify" || platform === "ntfy") return [[platform, mapNotifyPriority(platform, priority)]];
+          return [];
+        }),
+      ) : undefined;
+
       return {
         content: [
           {
@@ -84,7 +93,7 @@ export function registerNotifyTools(pi: ExtensionAPI): void {
             text: `Notification sending to ${notifPlatforms.length} platform(s): ${notifPlatforms.join(", ")}`,
           },
         ],
-        details: { platforms: notifPlatforms },
+        details: { platforms: notifPlatforms, priority, priorityByPlatform },
       };
     },
   });

package/packages/notify/types.ts

@@ -90,13 +90,15 @@ export interface NotifyConfig {
 }
 
 /** Parameters for the notify_user agent tool */
+export type NotifyPriority = "low" | "normal" | "high";
+
 export interface NotifyUserParams {
   /** Notification message body */
   message: string;
   /** Notification title (default: "Pi Notification") */
   title?: string;
   /** Priority level */
-  priority?: "low" | "normal" | "high";
+  priority?: NotifyPriority;
   /** Override platforms for this notification */
   platforms?: NotifyPlatform[];
 }
@@ -109,6 +111,8 @@ export interface NotifyResult {
   success: boolean;
   /** True when the notification was intentionally suppressed (e.g. window focused) */
   suppressed?: boolean;
+  /** Effective numeric priority for platforms that support it. */
+  priority?: number;
   /** Error message if failed */
   error?: string;
 }

package/packages/ralph/index.ts

@@ -145,8 +145,11 @@ export default function (pi: ExtensionAPI) {
     }
   });
 
-  // Inject ralph instructions when loop is active
-  pi.on("before_agent_start", async (event, ctx) => {
+  // Inject ralph instructions when loop is active.
+  // NOTE: injected as a hidden tail message (not the system prompt) so the
+  // cacheable prefix (system prompt + prior history) stays byte-stable across
+  // turns. The iteration number changes every turn and must never touch the prefix.
+  pi.on("before_agent_start", async (_event, ctx) => {
     const mgr = getManager(ctx, pi);
     const currentLoop = mgr.getCurrentLoop();
     if (!currentLoop) return;
@@ -165,9 +168,11 @@ export default function (pi: ExtensionAPI) {
     instructions += `- Otherwise, call ralph_done tool to proceed to next iteration`;
 
     return {
-      systemPrompt:
-        event.systemPrompt +
-        `\n[RALPH LOOP - ${state.name} - Iteration ${iterStr}]\n\n${instructions}`,
+      message: {
+        customType: "unipi-ralph-loop-reminder",
+        content: `[RALPH LOOP - ${state.name} - Iteration ${iterStr}]\n\n${instructions}`,
+        display: false,
+      },
     };
   });
 

package/packages/ralph/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-unipi/ralph",
-  "version": "2.4.0",
+  "version": "2.4.2",
   "description": "Long-running iterative development loops for Pi coding agent",
   "type": "module",
   "main": "index.ts",
@@ -27,8 +27,8 @@
     "access": "public"
   },
   "dependencies": {
-    "@pi-unipi/core": "2.4.0",
-    "@pi-unipi/info-screen": "2.4.0"
+    "@pi-unipi/core": "2.4.1",
+    "@pi-unipi/info-screen": "2.4.1"
   },
   "peerDependencies": {
     "@earendil-works/pi-ai": "^0.80.0",

package/packages/ralph/ralph-loop.ts

@@ -374,6 +374,8 @@ export class RalphLoopManager {
       return null;
     }
 
+    this.emitIterationDone(state);
+
     const needsReflection =
       state.reflectEvery > 0 && (state.iteration - 1) % state.reflectEvery === 0;
     if (needsReflection) state.lastReflectionAt = state.iteration;
@@ -384,6 +386,14 @@ export class RalphLoopManager {
     return { state, needsReflection };
   }
 
+  private emitIterationDone(state: LoopState): void {
+    this.emitFn(UNIPI_EVENTS.RALPH_ITERATION_DONE, {
+      name: state.name,
+      iteration: state.iteration - 1,
+      nextIteration: state.iteration,
+    });
+  }
+
   archiveLoop(name: string): boolean {
     const state = this.loadState(name);
     if (!state) return false;

package/packages/subagents/README.md

@@ -99,7 +99,9 @@ Create markdown files defining agent behavior:
 |---------|---------|--------------|
 | `enabled` | true | Enable/disable subagents |
 | `maxConcurrent` | 3 | Max agents running at once |
-| `types.{name}.enabled` | true | Toggle agent types |
+| `types.{name}.enabled` | true | Disable built-in or custom agent types. Disabled types are omitted from tool guidance and rejected before queueing. |
+
+For custom agents, JSON configuration and Markdown frontmatter are both enforced: the type can run only when neither source sets `enabled: false`. Configuration is loaded when the extension starts, so reload the session after changing enablement.
 
 ## License
 

package/packages/subagents/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-unipi/subagents",
-  "version": "2.4.0",
+  "version": "2.4.1",
   "description": "Subagents for UniPi — parallel execution, file locking, workflow integration",
   "type": "module",
   "main": "dist/index.js",
@@ -12,14 +12,12 @@
     }
   },
   "scripts": {
-    "build": "tsc",
+    "build": "rm -rf dist && tsc -p tsconfig.build.json && node scripts/verify-build.mjs",
+    "prepack": "npm run build",
     "dev": "tsc --watch",
     "test": "npx tsx --test src/__tests__/*.test.ts"
   },
   "dependencies": {
-    "@pi-unipi/core": "2.4.0",
-    "@pi-unipi/workflow": "2.4.0",
-    "@pi-unipi/info-screen": "2.4.0",
     "@earendil-works/pi-agent-core": "^0.80.0"
   },
   "devDependencies": {
@@ -30,8 +28,14 @@
     "@earendil-works/pi-tui": "^0.80.0",
     "typebox": "^1.1.38"
   },
+  "files": [
+    "dist/**",
+    "README.md"
+  ],
   "pi": {
-    "extensions": [],
+    "extensions": [
+      "./dist/index.js"
+    ],
     "skills": [],
     "prompts": [],
     "themes": []

package/packages/subagents/src/agent-manager.ts

@@ -10,7 +10,7 @@ import type { Model } from "@earendil-works/pi-ai";
 import type { AgentSession, ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { runAgent, type ToolActivity } from "./agent-runner.js";
 import { resolveModel, type ModelRegistry } from "./model-resolver.js";
-import type { AgentRecord, AgentConfig, AgentType, ThinkingLevel } from "./types.js";
+import type { AgentRecord, AgentConfig, AgentType, ThinkingLevel, SubagentsConfig } from "./types.js";
 import { BUILTIN_CONFIGS } from "./types.js";
 import { loadCustomAgents } from "./custom-agents.js";
 import { FileLock } from "./file-lock.js";
@@ -52,6 +52,7 @@ export class AgentManager {
   private onStart?: OnAgentStart;
   private maxConcurrent: number;
   private customAgents: Map<string, AgentConfig>;
+  private typeSettings: SubagentsConfig["types"];
 
   /** Per-file transparent locking for write agents. */
   readonly fileLock = new FileLock();
@@ -61,11 +62,18 @@ export class AgentManager {
   /** Number of currently running background agents. */
   private runningBackground = 0;
 
-  constructor(onComplete?: OnAgentComplete, maxConcurrent = DEFAULT_MAX_CONCURRENT, onStart?: OnAgentStart) {
+  constructor(
+    onComplete?: OnAgentComplete,
+    maxConcurrent = DEFAULT_MAX_CONCURRENT,
+    onStart?: OnAgentStart,
+    typeSettings: SubagentsConfig["types"] = {},
+    agentsCwd = process.cwd(),
+  ) {
     this.onComplete = onComplete;
     this.onStart = onStart;
     this.maxConcurrent = maxConcurrent;
-    this.customAgents = loadCustomAgents(process.cwd());
+    this.typeSettings = typeSettings;
+    this.customAgents = loadCustomAgents(agentsCwd);
     this.cleanupInterval = setInterval(() => this.cleanup(), 60_000);
   }
 
@@ -74,6 +82,27 @@ export class AgentManager {
     return this.customAgents.get(type) ?? BUILTIN_CONFIGS[type];
   }
 
+  /** Public agent types known from built-ins, custom files, or JSON config. */
+  getKnownTypes(): string[] {
+    return [...new Set([
+      ...Object.keys(BUILTIN_CONFIGS).filter((type) => type !== "name-gen"),
+      ...this.customAgents.keys(),
+      ...Object.keys(this.typeSettings),
+    ])];
+  }
+
+  /** A type is enabled only when both JSON config and agent frontmatter allow it. */
+  isTypeEnabled(type: AgentType): boolean {
+    const agentConfig = this.getAgentConfig(type);
+    return this.typeSettings[type]?.enabled !== false && agentConfig?.enabled !== false;
+  }
+
+  private assertTypeEnabled(type: AgentType): void {
+    if (!this.isTypeEnabled(type)) {
+      throw new Error(`Agent type "${type}" is disabled by configuration.`);
+    }
+  }
+
   setMaxConcurrent(n: number) {
     this.maxConcurrent = Math.max(1, n);
     this.drainQueue();
@@ -93,6 +122,10 @@ export class AgentManager {
     prompt: string,
     options: SpawnOptions,
   ): string {
+    // Reject before allocating a record or queue entry. This applies equally to
+    // foreground and background spawns and avoids ghost disabled agents.
+    this.assertTypeEnabled(type);
+
     const id = randomUUID().slice(0, 17);
     const abortController = new AbortController();
     const record: AgentRecord = {
@@ -125,10 +158,13 @@ export class AgentManager {
     if (options.isBackground) this.runningBackground++;
     this.onStart?.(record);
 
-    // Resolve model: explicit input > config model > parent model
+    const agentConfig = this.getAgentConfig(type);
+
+    // Resolve model: explicit input > per-agent config > parent model.
     let model = options.model;
-    if (options.modelInput && options.modelRegistry) {
-      const resolved = resolveModel(options.modelInput, options.modelRegistry);
+    const modelInput = options.modelInput ?? agentConfig?.model;
+    if (!model && modelInput && options.modelRegistry) {
+      const resolved = resolveModel(modelInput, options.modelRegistry);
       if (typeof resolved === "string") {
         // Error message — return early with error
         record.status = "error";
@@ -143,15 +179,14 @@ export class AgentManager {
       model = resolved;
     }
 
-    const agentConfig = this.getAgentConfig(type);
     const promise = runAgent(ctx, type, prompt, {
       pi,
       model,
       agentConfig,
-      maxTurns: options.maxTurns,
-      isolated: options.isolated,
-      inheritContext: options.inheritContext,
-      thinkingLevel: options.thinkingLevel,
+      maxTurns: options.maxTurns ?? agentConfig?.maxTurns,
+      isolated: options.isolated ?? agentConfig?.isolated,
+      inheritContext: options.inheritContext ?? agentConfig?.inheritContext,
+      thinkingLevel: options.thinkingLevel ?? agentConfig?.thinking,
       signal: record.abortController!.signal,
       onToolActivity: (activity) => {
         if (activity.type === "end") record.toolUses++;

package/packages/subagents/src/core-compat.ts

@@ -0,0 +1,38 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+
+export const MODULES = { SUBAGENTS: "subagents" } as const;
+
+export const UNIPI_EVENTS = {
+  MODULE_READY: "unipi:module:ready",
+  BADGE_GENERATE_REQUEST: "unipi:badge:generate:request",
+} as const;
+
+export interface UnipiBadgeGenerateRequestEvent {
+  conversationSummary?: string;
+}
+
+export function emitEvent(
+  pi: Pick<ExtensionAPI, "events">,
+  eventName: string,
+  payload: unknown,
+): boolean {
+  try {
+    pi.events.emit(eventName, payload);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export async function withHerdrBlocked<T>(
+  pi: Pick<ExtensionAPI, "events">,
+  label: string,
+  fn: () => Promise<T>,
+): Promise<T> {
+  emitEvent(pi, "herdr:blocked", { active: true, label });
+  try {
+    return await fn();
+  } finally {
+    emitEvent(pi, "herdr:blocked", { active: false, label });
+  }
+}

package/packages/subagents/src/global.d.ts

@@ -0,0 +1,7 @@
+import type { InfoRegistryLike } from "@pi-unipi/core/global-types";
+
+declare global {
+  var __unipi_info_registry: InfoRegistryLike | undefined;
+}
+
+export {};

package/packages/subagents/src/index.ts

@@ -12,7 +12,7 @@ import { Type } from "typebox";
 import { existsSync, readdirSync } from "node:fs";
 import { join } from "node:path";
 import { homedir } from "node:os";
-import { emitEvent, MODULES, UNIPI_EVENTS, withHerdrBlocked, type UnipiBadgeGenerateRequestEvent } from "@pi-unipi/core";
+import { emitEvent, MODULES, UNIPI_EVENTS, withHerdrBlocked, type UnipiBadgeGenerateRequestEvent } from "./core-compat.js";
 import { AgentManager } from "./agent-manager.js";
 import { initConfig } from "./config.js";
 import { type AgentActivity, type NotificationDetails, BUILTIN_TYPES } from "./types.js";
@@ -246,6 +246,7 @@ export default function (pi: ExtensionAPI) {
         description: record.description,
       });
     },
+    config.types,
   );
 
   // Build notification details for the message renderer
@@ -494,6 +495,8 @@ export default function (pi: ExtensionAPI) {
   // ---- Agent tool ----
 
   const builtinTypes = BUILTIN_TYPES.join(", ");
+  const enabledTypes = manager.getKnownTypes().filter((type) => manager.isTypeEnabled(type));
+  const availableTypes = enabledTypes.join(", ") || "none";
 
   pi.registerTool(
     defineTool({
@@ -501,7 +504,7 @@ export default function (pi: ExtensionAPI) {
       label: "Spawn Helper",
       description: `Launch a sub-agent for parallel work.
 
-Available agent types: ${builtinTypes}
+Available agent types: ${availableTypes}
 Custom types can be defined in:
 - ~/.unipi/config/agents/<name>.md (global)
 - <workspace>/.unipi/config/agents/<name>.md (project)
@@ -514,7 +517,7 @@ Guidelines:
 - Agents inherit the parent model by default`,
       parameters: Type.Object({
         type: Type.String({
-          description: `Agent type: ${builtinTypes}, or custom type from ~/.unipi/config/agents/*.md`,
+          description: `Enabled agent type: ${availableTypes}`,
         }),
         prompt: Type.String({
           description: "The task for the agent to perform.",

package/packages/subagents/src/widget.ts

@@ -51,13 +51,6 @@ function formatTurns(turn: number, max?: number): string {
   return max != null ? `⟳${turn}≤${max}` : `⟳${turn}`;
 }
 
-/** Format token count compactly: "33.8k token", "1.2M token". */
-function formatTokens(count: number): string {
-  if (count >= 1_000_000) return `${(count / 1_000_000).toFixed(1)}M token`;
-  if (count >= 1_000) return `${(count / 1_000).toFixed(1)}k token`;
-  return `${count} token`;
-}
-
 /**
  * Build a human-readable activity string from currently-running tools.
  * Groups by tool type with counts: "reading 3 files, searching 2 patterns".