osdy-pi 1.11.3 → 1.11.4

package/README.md

@@ -303,7 +303,7 @@ Before rename or removal, close this Pi process when it uses the target and **ma
 | Header and mascot | Independently selectable `osdy-theme`/`neon` headers and `current`/`bts` mascots |
 | Messages | Native colored user cards without emojis and plain assistant Markdown with a separate assistant `🦝` row |
 | Input | Responsive auto editor by default, with selectable simple Pi-native or extended framed modes |
-| Status | Theme-aware Braille spinner and animated working label, responsive footer metrics, dynamic extension statuses, and Codex subscription quota with low-capacity emphasis |
+| Status | Six activity labels with compact per-state glyphs and a shared theme-color pulse, responsive footer metrics, dynamic extension statuses, and Codex subscription quota with low-capacity emphasis |
 | Local analytics | Four keyboard-selectable pages with shared filters, token charts, estimated cost, and private metadata-only history from new assistant turns |
 | Git | Working-tree summary and a centered, filterable diff panel |
 | Audio | Optional event sounds on macOS and Windows |
@@ -475,7 +475,20 @@ The default `auto` editor mode preserves the responsive behavior: it uses the fr
 
 In auto or extended mode at a non-small width, the framed editor shows the model and thinking level in its title and session usage in its footer. For an account-profile launch, the left title shows the active profile name instead of `Osdy-Pi`. When the native editor is effective (simple mode or any small terminal), the Osdy footer instead shows model, active profile when present, thinking, and usage rows before its path/branch and status rows. It uses the currently active Pi/Osdy theme palette; no separate editor theme selector exists. Usage covers input, output, cache read, cache write when present, cost, and context. If Pi supports autocomplete, the editor uses Pi's native autocomplete rendering while the completion UI is visible.
 
-While work is active, Osdy Pi shows the original Braille spinner above the editor in the selected theme's accent color. A two-color wave travels across the `Working...` and `Running ...` letters: the current letter uses the active theme's `accent`, the trailing letter uses `warning`, and the rest use `text`. Only the current `accent` letter tries the active theme's bold styling; this is a terminal-dependent visual trial, not a change to font size. The trailing `warning` letter stays plain, as does the accent spinner. The spinner and label update when the theme changes. Osdy Pi hides Pi's built-in working row while enabled to avoid a duplicate indicator.
+While work is active, Osdy Pi centers an activity label and compact animated glyph above the editor:
+
+| Activity | Glyph frames | Meaning |
+| --- | --- | --- |
+| `Thinking...` | ◌ ◎ ◉ ● | Waiting on the model without active tools—not guaranteed internal reasoning. |
+| `Exploring...` | ✶ ✷ ✸ ✹ | Recognized reads, searches, and documentation tools. |
+| `Verifying...` | ◇ ◈ ◆ ◈ | Recognized checks. |
+| `Working...` | ✻ ✼ ✽ ❋ | Recognized mutations. |
+| `Delegating...` | ✧ ✦ ✧ | Subagent handoffs. |
+| `Executing...` | ◴ ◷ ◶ ◵ | Unknown or ambiguous tools. |
+
+When tools overlap, the latest remaining tool owns the display. All glyphs share a brightness pulse through the active theme's `mdQuoteBorder`, `thinkingHigh`, `accent`, and `borderAccent` colors; the animation signals activity, not measured percentage progress. Glyphs and labels use a single 80 ms timer, with no new controls or settings.
+
+A two-color wave travels across the label: the current letter uses the active theme's `accent`, the trailing letter uses `warning`, and the rest use `text`. Only the current `accent` letter tries the active theme's bold styling; this is a terminal-dependent visual trial, not a change to font size. The trailing `warning` letter and glyph stay plain. The glyph and label update when the theme changes. Osdy Pi hides Pi's built-in working row while enabled to avoid a duplicate indicator.
 
 ## Working tree and diff
 

package/extensions/osdy-pi/constants.ts

@@ -1,20 +1,26 @@
 import { visibleWidth } from "@earendil-works/pi-tui";
-import type { HeaderVariant, MascotChoice } from "./types.js";
+import type { HeaderVariant, MascotChoice, WorkingActivity } from "./types.js";
 
 export const ANIMATION_ENABLED = true;
 export const ANIMATION_INTERVAL_MS = 30;
 export const INTRO_ANIMATION_FRAMES = 28;
-export const WORKING_SPINNER_FRAMES = [
-  "⠋",
-  "⠙",
-  "⠹",
-  "⠸",
-  "⠼",
-  "⠴",
-  "⠦",
-  "⠧",
-  "⠇",
-  "⠏",
+export const WORKING_ACTIVITY_FRAMES: Record<WorkingActivity, readonly string[]> = {
+  thinking: ["◌", "◎", "◉", "●"],
+  exploring: ["✶", "✷", "✸", "✹"],
+  verifying: ["◇", "◈", "◆", "◈"],
+  working: ["✻", "✼", "✽", "❋"],
+  delegating: ["✧", "✦", "✧"],
+  executing: ["◴", "◷", "◶", "◵"],
+};
+export const WORKING_SYMBOL_PULSE: readonly string[] = [
+  "mdQuoteBorder",
+  "thinkingHigh",
+  "accent",
+  "borderAccent",
+  "accent",
+  "thinkingHigh",
+  "mdQuoteBorder",
+  "mdQuoteBorder",
 ];
 export const WORKING_WIDGET_KEY = "osdy-pi-working";
 export const WORKING_TREE_WIDGET_KEY = "osdy-pi-working-tree";

package/extensions/osdy-pi/runtime-helpers.test.ts

@@ -101,6 +101,7 @@ function createWorkingTreeState(): WorkingTreeState {
 function createWorkingState(): WorkingWidgetState {
 	return {
 		active: false,
+		activity: "thinking",
 		label: "Working...",
 		frame: 0,
 		timer: undefined,

package/extensions/osdy-pi/runtime.test.ts

@@ -111,6 +111,12 @@ void test("Control Center refuses RPC, print, JSON and missing UI without custom
  }
 });
 
+void test("runtime forwards tool identity and unknown start args to the working controller", () => {
+	const source = readFileSync(new URL("./runtime.ts", import.meta.url), "utf8");
+	assert.match(source, /controller\.onToolStart\(event\.toolName, event\.toolCallId, event\.args\)/);
+	assert.match(source, /controller\.onToolEnd\(event\.toolCallId\)/);
+});
+
 void test("Control Center reports custom UI startup errors", async () => {
  const notices: string[] = [];
  await showControlCenter({
@@ -149,7 +155,7 @@ void test("shared visual actions apply immediately, save the complete settings,
 				editorEffective: true, smallMode: false, workingTreeEnabled: false, workingTreePlacement: "aboveEditor",
 				codexUsage: { kind: "idle" }, fallbackEditorFactory: undefined, tui: undefined };
 			const tree: WorkingTreeState = { enabled: false, visible: false, loading: false, snapshot: null, error: undefined, tui: undefined };
-			const working: WorkingWidgetState = { active: false, label: "Working", frame: 0, timer: undefined, tui: undefined };
+			const working: WorkingWidgetState = { active: false, activity: "thinking", label: "Working", frame: 0, timer: undefined, tui: undefined };
 			let mounts = 0;
 			let editor: unknown = "unchanged";
 			const ctx = { hasUI: true, ui: { setHeader: () => { mounts++; }, setFooter: () => {}, setWidget: () => {},
@@ -216,7 +222,7 @@ async function focusFixture(options: { boundary?: boolean; throwApply?: boolean;
 		editorEffective: !smallMode, smallMode, workingTreeEnabled: false, workingTreePlacement: "aboveEditor",
 		codexUsage: { kind: "idle" }, fallbackEditorFactory: fallback, tui };
 	const tree: WorkingTreeState = { enabled: false, visible: false, loading: false, snapshot: null, error: undefined, tui: undefined };
-	const working: WorkingWidgetState = { active: false, label: "Working", frame: 0, timer: undefined, tui: undefined };
+	const working: WorkingWidgetState = { active: false, activity: "thinking", label: "Working", frame: 0, timer: undefined, tui: undefined };
 	let resolveSave: () => void = () => {};
 	let rejectSave: () => void = () => {};
 	const store = { path: "/unused", load: () => Promise.reject(new Error("must not load")), save: (settings: GlobalEditorSettings) => new Promise<void>((resolve, reject) => {

package/extensions/osdy-pi/runtime.ts

@@ -1093,7 +1093,8 @@ export async function registerOsdyPi(
 	};
 	const workingState: WorkingWidgetState = {
 		active: false,
-		label: "Working...",
+		activity: "thinking",
+		label: "Thinking...",
 		frame: 0,
 		timer: undefined,
 		tui: undefined,
@@ -1195,10 +1196,10 @@ export async function registerOsdyPi(
 		}
 	});
 	pi.on("tool_execution_start", (event) =>
-		controller.onToolStart(event.toolName),
+		controller.onToolStart(event.toolName, event.toolCallId, event.args),
 	);
 	pi.on("tool_execution_end", (event, ctx) => {
-		controller.onToolEnd();
+		controller.onToolEnd(event.toolCallId);
 		audioRouter.onToolExecutionEnd(event.isError === true, ctx);
 		if (state.enabled) clearGentleShellChangesWidget(ctx);
 		if (

package/extensions/osdy-pi/types.ts

@@ -76,8 +76,17 @@ export type OsdyState = {
 	workingTreePlacement: WorkingTreePlacement;
 };
 
+export type WorkingActivity =
+	| "thinking"
+	| "exploring"
+	| "verifying"
+	| "working"
+	| "delegating"
+	| "executing";
+
 export type WorkingWidgetState = {
 	active: boolean;
+	activity: WorkingActivity;
 	label: string;
 	frame: number;
 	timer: ReturnType<typeof setInterval> | undefined;

package/extensions/osdy-pi/working-activity.ts

@@ -0,0 +1,57 @@
+import type { WorkingActivity } from "./types.js";
+
+export const WORKING_ACTIVITY_LABELS: Record<WorkingActivity, string> = {
+	thinking: "Thinking...",
+	exploring: "Exploring...",
+	verifying: "Verifying...",
+	working: "Working...",
+	delegating: "Delegating...",
+	executing: "Executing...",
+};
+
+function stringArgument(args: unknown, key: string): string | undefined {
+	if (typeof args !== "object" || args === null || Array.isArray(args)) return undefined;
+	const value = (args as Record<string, unknown>)[key];
+	return typeof value === "string" ? value : undefined;
+}
+
+function isSimpleCheck(command: string): boolean {
+	// Deliberately not a shell parser: reject quoting, expansion and shell syntax.
+	// Only plain command/argument tokens can enter the anchored allowlist.
+	if (!/^[a-zA-Z0-9_./:=@%+*,? -]+$/.test(command)) return false;
+	const text = command.trim();
+	return /^(?:npm test|npm run (?:test|lint|typecheck|build)|node (?:--experimental-strip-types )?--test|bun test|npx tsc --noEmit|pytest|go test)(?: +[a-zA-Z0-9_./:=@%+*,?-]+)*$/.test(text);
+}
+
+export function classifyWorkingActivity(toolName: string, args: unknown): WorkingActivity {
+	switch (toolName) {
+		case "read": case "grep": case "find": case "ls":
+		case "codegraph": case "symbol_search": case "project_report": case "module_report":
+		case "read_symbol": case "read_enclosing": case "ast_grep_search":
+		case "resolve-library-id": case "query-docs": case "get-library-docs":
+		case "subagent_status": case "subagent_result":
+			return "exploring";
+		case "mcp": case "mcp__context7": {
+			// Only exact documentation selectors; never recurse into wrapped arguments.
+			const tool = stringArgument(args, "tool");
+			return tool === "resolve-library-id" || tool === "query-docs" || tool === "get-library-docs"
+				|| tool === "context7_resolve-library-id" || tool === "context7_query-docs" ? "exploring" : "executing";
+		}
+		case "edit": case "write": case "ast_grep_replace":
+			return "working";
+		case "subagent_run":
+			return "delegating";
+		case "lens_diagnostics":
+			return "verifying";
+		case "intercom": {
+			const action = stringArgument(args, "action");
+			return action === "send" || action === "ask" || action === "handover" ? "delegating" : "executing";
+		}
+		case "bash": {
+			const command = stringArgument(args, "command");
+			return command !== undefined && isSimpleCheck(command) ? "verifying" : "executing";
+		}
+		default:
+			return "executing";
+	}
+}

package/extensions/osdy-pi/working-animation.test.ts

@@ -2,7 +2,7 @@ import assert from "node:assert/strict";
 import { registerHooks } from "node:module";
 import test from "node:test";
 import { visibleWidth } from "@earendil-works/pi-tui";
-import type { SimpleTheme, WorkingWidgetState } from "./types.js";
+import type { SimpleTheme, WorkingActivity, WorkingWidgetState } from "./types.js";
 
 registerHooks({
 	resolve(specifier, context, nextResolve) {
@@ -19,38 +19,87 @@ registerHooks({
 
 // @ts-expect-error Node's native TypeScript runner resolves test-only TypeScript source imports.
 const { renderWorkingWidget } = await import("./working-animation.ts");
-// @ts-expect-error Node's native TypeScript runner resolves test-only TypeScript source imports.
-const { WORKING_SPINNER_FRAMES } = await import("./constants.ts");
+const expectedFrames: Record<WorkingActivity, readonly string[]> = {
+	thinking: ["◌", "◎", "◉", "●"],
+	exploring: ["✶", "✷", "✸", "✹"],
+	verifying: ["◇", "◈", "◆", "◈"],
+	working: ["✻", "✼", "✽", "❋"],
+	delegating: ["✧", "✦", "✧"],
+	executing: ["◴", "◷", "◶", "◵"],
+};
+const activities: readonly WorkingActivity[] = [
+	"thinking", "exploring", "verifying", "working", "delegating", "executing",
+];
+const expectedPulse = [
+	"mdQuoteBorder", "thinkingHigh", "accent", "borderAccent",
+	"accent", "thinkingHigh", "mdQuoteBorder", "mdQuoteBorder",
+];
+
+function symbol(
+	theme: SimpleTheme,
+	frame: number,
+	activity: WorkingActivity = "thinking",
+): string {
+	const frames = expectedFrames[activity];
+	const color = expectedPulse[frame % expectedPulse.length] ?? "";
+	const glyph = frames[frame % frames.length] ?? "";
+	return theme.fg(color, glyph);
+}
 
 function state(label: string, frame = 0, active = true): WorkingWidgetState {
-	return { active, label, frame, timer: undefined, tui: undefined };
+	return { active, activity: "thinking", label, frame, timer: undefined, tui: undefined };
 }
 
 function theme(base: string, accent: string, warning: string): SimpleTheme {
 	return {
 		fg(name, text) {
-			const color = name === "accent" ? accent : name === "warning" ? warning : base;
-			return `\u001B[${color}m${text}\u001B[0m`;
+			const colors: Record<string, string> = {
+				accent,
+				warning,
+				mdQuoteBorder: `2;${base}`,
+				thinkingHigh: `2;${accent}`,
+				borderAccent: `1;${accent}`,
+			};
+			return `\u001B[${colors[name] ?? base}m${text}\u001B[0m`;
 		},
 	};
 }
 
 const palette = theme("37", "33", "34");
-void test("original Braille frames advance every 80ms tick, wrap at ten, and use theme accent", () => {
-	assert.equal(WORKING_SPINNER_FRAMES.length, 10);
-	for (let frame = 0; frame <= WORKING_SPINNER_FRAMES.length; frame += 1) {
-		const glyph = WORKING_SPINNER_FRAMES[frame % WORKING_SPINNER_FRAMES.length] ?? "";
-		const spinner = palette.fg("accent", glyph);
-		const line = renderWorkingWidget(state("Working...", frame), palette, 40)[0] ?? "";
-		assert.ok(line.includes(`${spinner} `), `frame ${frame} uses accent Braille ${glyph}`);
-		assert.equal(visibleWidth(spinner), 1);
-	}
+for (const activity of activities) {
+	void test(`${activity} uses its approved one-cell frames and full shared pulse cycle`, () => {
+		const frames = expectedFrames[activity];
+		for (const glyph of frames) assert.equal(visibleWidth(glyph), 1, glyph);
+		for (let frame = 0; frame < 24; frame += 1) {
+			const current = { ...state("Working...", frame), activity };
+			const line = renderWorkingWidget(current, palette, 40)[0] ?? "";
+			assert.ok(line.includes(`${symbol(palette, frame, activity)} `), `${activity} frame ${frame}`);
+			assert.equal(visibleWidth(line.trimStart()), 12, "one symbol cell plus separator and label");
+		}
+	});
+}
+
+void test("letter wave advances independently when the symbol wraps", () => {
 	const at = (frame: number) => renderWorkingWidget(state("Working...", frame), palette, 40)[0] ?? "";
-	assert.ok(at(0).includes(`${palette.fg("accent", WORKING_SPINNER_FRAMES[0] ?? "")} ${palette.fg("accent", "W")}${palette.fg("text", "o")}`));
+	assert.ok(at(0).includes(`${symbol(palette, 0)} ${palette.fg("accent", "W")}${palette.fg("text", "o")}`));
 	assert.ok(at(0).includes(`${palette.fg("text", ".")}${palette.fg("warning", ".")}`), "frame zero wraps the trailing position to the last grapheme");
 	assert.ok(at(1).includes(`${palette.fg("warning", "W")}${palette.fg("accent", "o")}`), "frame one trails the current accent");
 	const runningAt = (frame: number) => renderWorkingWidget(state("Running build...", frame), palette, 40)[0] ?? "";
-	assert.notEqual(runningAt(0), runningAt(10), "letter wave advances when the spinner wraps");
+	assert.ok(runningAt(4).includes(`${palette.fg("warning", "n")}${palette.fg("accent", "i")}`), "letter wave advances when the symbol wraps");
+});
+
+void test("every activity resolves the live theme for each pulse phase", () => {
+	const changedTheme = theme("36", "35", "32");
+	for (const activity of activities) {
+		for (let frame = 0; frame < expectedPulse.length; frame += 1) {
+			const current = { ...state("AB", frame), activity };
+			const first = renderWorkingWidget(current, palette, 20)[0] ?? "";
+			const changed = renderWorkingWidget(current, changedTheme, 20)[0] ?? "";
+			assert.ok(first.includes(symbol(palette, frame, activity)));
+			assert.ok(changed.includes(symbol(changedTheme, frame, activity)));
+			assert.ok(!changed.includes(symbol(palette, frame, activity)), "old symbol color is not cached");
+		}
+	}
 });
 
 void test("Running label skips spaces, wraps the trailing grapheme, and follows theme on next render", () => {
@@ -58,8 +107,8 @@ void test("Running label skips spaces, wraps the trailing grapheme, and follows
 	const changedTheme = theme("36", "35", "32");
 	const first = renderWorkingWidget(state(label, 7), palette, 40)[0] ?? "";
 	const changed = renderWorkingWidget(state(label, 7), changedTheme, 40)[0] ?? "";
-	assert.ok(first.includes(`${palette.fg("accent", WORKING_SPINNER_FRAMES[7] ?? "")} `));
-	assert.ok(changed.includes(`${changedTheme.fg("accent", WORKING_SPINNER_FRAMES[7] ?? "")} `));
+	assert.ok(first.includes(`${symbol(palette, 7)} `));
+	assert.ok(changed.includes(`${symbol(changedTheme, 7)} `));
 	assert.ok(first.includes(`${palette.fg("warning", "g")} ${palette.fg("accent", "b")}`));
 	assert.ok(changed.includes(`${changedTheme.fg("warning", "g")} ${changedTheme.fg("accent", "b")}`));
 	assert.ok(!changed.includes(palette.fg("warning", "g")), "old trailing color does not persist after theme change");
@@ -81,7 +130,7 @@ void test("only the moving accent grapheme is bold without changing width", () =
 		...palette,
 		bold(text: string) { return `\u001B[1m${text}\u001B[22m`; },
 	};
-	const spinner = (frame: number) => boldTheme.fg("accent", WORKING_SPINNER_FRAMES[frame] ?? "");
+	const spinner = (frame: number) => symbol(boldTheme, frame);
 	const accent = (segment: string) => boldTheme.bold(boldTheme.fg("accent", segment));
 	const label = "A\u0301👩‍💻 B";
 	for (const [frame, expected] of [
@@ -114,7 +163,7 @@ void test("trailing warning stays plain even when theme exposes inverse and bold
 		[1, `${pulseTheme.fg("warning", "A\u0301")}${accent("👩‍💻")} ${pulseTheme.fg("text", "B")}`],
 		[2, `${pulseTheme.fg("text", "A\u0301")}${pulseTheme.fg("warning", "👩‍💻")} ${accent("B")}`],
 	] as const) {
-		const spinner = pulseTheme.fg("accent", WORKING_SPINNER_FRAMES[frame] ?? "");
+		const spinner = symbol(pulseTheme, frame);
 		const line = renderWorkingWidget(state(label, frame), pulseTheme, 40)[0] ?? "";
 		assert.ok(line.includes(`${spinner} ${expected}`), `frame ${frame} keeps warning plain`);
 		assert.equal(line.split("\u001B[1m").length - 1, 1, "spinner and warning stay unbolded");
@@ -122,7 +171,7 @@ void test("trailing warning stays plain even when theme exposes inverse and bold
 		assert.equal(visibleWidth(line.trimStart()), 2 + visibleWidth(label));
 	}
 	const single = renderWorkingWidget(state("A", 3), pulseTheme, 20)[0] ?? "";
-	assert.ok(single.includes(`${pulseTheme.fg("accent", WORKING_SPINNER_FRAMES[3] ?? "")} ${accent("A")}`));
+	assert.ok(single.includes(`${symbol(pulseTheme, 3)} ${accent("A")}`));
 	assert.equal(single.split("\u001B[1m").length - 1, 1);
 	assert.ok(!single.includes("\u001B[7m"));
 	const changedTheme = {
@@ -138,7 +187,7 @@ void test("trailing warning stays plain even when theme exposes inverse and bold
 void test("tab-separated label skips whitespace when advancing the highlight", () => {
 	const label = "A\tB";
 	const line = renderWorkingWidget(state(label, 1), palette, 20)[0] ?? "";
-	assert.ok(line.includes(`${palette.fg("accent", WORKING_SPINNER_FRAMES[1] ?? "")} ${palette.fg("warning", "A")}\t${palette.fg("accent", "B")}`));
+	assert.ok(line.includes(`${symbol(palette, 1)} ${palette.fg("warning", "A")}\t${palette.fg("accent", "B")}`));
 	assert.equal(visibleWidth(line.trimStart()), 2 + visibleWidth(label));
 });
 
@@ -150,17 +199,22 @@ void test("combining marks and ZWJ emoji remain whole graphemes in the traveling
 		[2, `${palette.fg("text", "A\u0301")}${palette.fg("warning", "👩‍💻")} ${palette.fg("accent", "B")}`],
 	] as const) {
 		const line = renderWorkingWidget(state(label, frame), palette, 40)[0] ?? "";
-		assert.ok(line.includes(`${palette.fg("accent", WORKING_SPINNER_FRAMES[frame] ?? "")} ${expected}`), `frame ${frame} preserves graphemes`);
+		assert.ok(line.includes(`${symbol(palette, frame)} ${expected}`), `frame ${frame} preserves graphemes`);
 		assert.equal(visibleWidth(line.trimStart()), 2 + visibleWidth(label));
 	}
 });
 
 void test("inactive widget renders nothing; narrow output fits and full output stays centered", () => {
 	assert.deepEqual(renderWorkingWidget(state("Working...", 18, false), palette, 20), []);
-	for (const frame of [0, 2, 4, 6]) {
-		const line = renderWorkingWidget(state("Working...", frame), palette, 5)[0] ?? "";
-		assert.equal(visibleWidth(line), 5);
+	for (const activity of activities) {
+		assert.deepEqual(renderWorkingWidget({ ...state("Working...", 18, false), activity }, palette, 20), []);
+		for (const frame of [0, 1, 2, 3, 4, 6, 7, 8]) {
+			for (const width of [0, 1, 2, 5]) {
+				const line = renderWorkingWidget({ ...state("Working...", frame), activity }, palette, width)[0] ?? "";
+				assert.equal(visibleWidth(line), Math.max(1, width), `${activity} frame ${frame} width ${width}; existing clipping has a one-cell minimum`);
+			}
+		}
+		const centered = renderWorkingWidget({ ...state("Working..."), activity }, palette, 20)[0] ?? "";
+		assert.equal(centered.match(/^ */)?.[0].length, 4);
 	}
-	const centered = renderWorkingWidget(state("Working..."), palette, 20)[0] ?? "";
-	assert.equal(centered.match(/^ */)?.[0].length, 4);
 });

package/extensions/osdy-pi/working-animation.ts

@@ -1,17 +1,19 @@
-import { WORKING_SPINNER_FRAMES } from "./constants.js";
+import { WORKING_ACTIVITY_FRAMES, WORKING_SYMBOL_PULSE } from "./constants.js";
 import type { SimpleTheme, WorkingWidgetState } from "./types.js";
 import { fitCenterVisible } from "./utils.js";
 const graphemes = new Intl.Segmenter(undefined, { granularity: "grapheme" });
 const isWhitespace = (segment: string) => /\s/u.test(segment);
 
-/** Render the theme-accent Braille spinner beside a theme-aware traveling letter highlight. */
+/** Render a compact activity symbol with a shared theme pulse beside the traveling letter highlight. */
 export function renderWorkingWidget(
 	state: WorkingWidgetState,
 	theme: SimpleTheme,
 	width: number,
 ): string[] {
 	if (!state.active) return [];
-	const spinner = WORKING_SPINNER_FRAMES[state.frame % WORKING_SPINNER_FRAMES.length] ?? "";
+	const frames = WORKING_ACTIVITY_FRAMES[state.activity];
+	const symbol = frames[state.frame % frames.length] ?? "";
+	const symbolColor = WORKING_SYMBOL_PULSE[state.frame % WORKING_SYMBOL_PULSE.length] ?? "mdQuoteBorder";
 	const segments = [...graphemes.segment(state.label)].map(({ segment }) => segment);
 	const letterCount = segments.filter((segment) => !isWhitespace(segment)).length;
 	const highlighted = letterCount > 0 ? state.frame % letterCount : -1;
@@ -29,5 +31,5 @@ export function renderWorkingWidget(
 			return theme.fg("text", segment);
 		})
 		.join("");
-	return [fitCenterVisible(`${theme.fg("accent", spinner)} ${label}`, width)];
+	return [fitCenterVisible(`${theme.fg(symbolColor, symbol)} ${label}`, width)];
 }

package/extensions/osdy-pi/working-controller.test.ts

@@ -0,0 +1,115 @@
+import assert from "node:assert/strict";
+import { registerHooks } from "node:module";
+import test from "node:test";
+import type { WorkingWidgetState } from "./types.js";
+
+registerHooks({ resolve(specifier, context, nextResolve) {
+	if (specifier.startsWith(".") && specifier.endsWith(".js") && context.parentURL?.endsWith(".ts"))
+		return nextResolve(`${specifier.slice(0, -3)}.ts`, context);
+	return nextResolve(specifier, context);
+} });
+const { createWorkingController } = await import("./working-controller.js");
+
+function fixture() {
+	const state = { enabled: true };
+	const working: WorkingWidgetState = { active: false, activity: "thinking", label: "Thinking...", frame: 0, timer: undefined, tui: undefined };
+	return { state, working, controller: createWorkingController(state, working) };
+}
+
+void test("agent without tools thinks and matching ends restore the newest remaining tool", (t) => {
+	t.mock.timers.enable({ apis: ["setInterval"] });
+	const { working, controller: c } = fixture();
+	c.onAgentStart(); assert.equal(working.label, "Thinking...");
+	c.onToolStart("read", "a", {}); assert.equal(working.activity, "exploring");
+	c.onToolStart("write", "b", {}); assert.equal(working.label, "Working...");
+	c.onToolStart("bash", "c", { command: "npm test" }); assert.equal(working.label, "Verifying...");
+	c.onToolEnd("b"); assert.equal(working.activity, "verifying");
+	c.onToolEnd("c"); assert.equal(working.label, "Exploring...");
+	c.onToolEnd("a"); assert.equal(working.label, "Thinking...");
+	c.onAgentEnd(); assert.equal(working.active, false); assert.equal(working.timer, undefined);
+});
+
+void test("duplicate starts and unmatched ends neither replace nor reorder activity", (t) => {
+	t.mock.timers.enable({ apis: ["setInterval"] });
+	const { working, controller: c } = fixture();
+	c.onToolStart("read", "a"); c.onToolStart("subagent_run", "b");
+	c.onToolStart("write", "a"); c.onToolEnd("missing");
+	assert.equal(working.label, "Delegating...");
+	c.onToolEnd("b"); assert.equal(working.label, "Exploring...");
+	c.onToolEnd("a"); assert.equal(working.active, false);
+	c.onToolEnd("a"); assert.equal(working.timer, undefined);
+});
+
+void test("single 80ms clock stops while disabled and resumes the current tool", (t) => {
+	t.mock.timers.enable({ apis: ["setInterval"] });
+	const { state, working, controller: c } = fixture();
+	c.onAgentStart(); const timer = working.timer;
+	c.onToolStart("read", "a"); c.refreshWorking(); assert.equal(working.timer, timer);
+	t.mock.timers.tick(79); assert.equal(working.frame, 0);
+	t.mock.timers.tick(1); assert.equal(working.frame, 1);
+	state.enabled = false; c.stopWorking();
+	t.mock.timers.tick(800); assert.equal(working.frame, 1); assert.equal(working.timer, undefined);
+	c.onToolStart("write", "b"); assert.equal(working.active, false);
+	state.enabled = true; c.refreshWorking(); assert.equal(working.label, "Working...");
+	t.mock.timers.tick(80); assert.equal(working.frame, 2);
+	c.onToolEnd("b"); assert.equal(working.label, "Exploring...");
+	c.onShutdown(); assert.equal(working.timer, undefined); assert.equal(working.active, false);
+	t.mock.timers.tick(800); assert.equal(working.frame, 2);
+	c.refreshWorking(); assert.equal(working.active, false);
+});
+
+void test("agent end clears tool identities before the next agent starts", (t) => {
+	t.mock.timers.enable({ apis: ["setInterval"] });
+	const { working, controller: c } = fixture();
+	c.onToolStart("unknown", "a"); assert.equal(working.label, "Executing...");
+	c.onAgentEnd(); c.onAgentStart(); c.onToolEnd("a");
+	assert.equal(working.label, "Thinking...");
+	c.onToolStart("edit", "a"); assert.equal(working.label, "Working...");
+	c.onShutdown(); assert.equal(working.activity, "thinking");
+});
+
+void test("bounded exact tool classification and unknown argument narrowing", (t) => {
+	t.mock.timers.enable({ apis: ["setInterval"] });
+	const { working, controller: c } = fixture();
+	const cases: Array<[string, unknown, string]> = [];
+	for (const name of ["read", "grep", "find", "ls", "codegraph", "symbol_search", "project_report", "module_report", "read_symbol", "read_enclosing", "ast_grep_search", "resolve-library-id", "query-docs", "get-library-docs", "subagent_status", "subagent_result"])
+		cases.push([name, undefined, "Exploring..."]);
+	for (const name of ["edit", "write", "ast_grep_replace"]) cases.push([name, undefined, "Working..."]);
+	cases.push(["subagent_run", undefined, "Delegating..."], ["lens_diagnostics", null, "Verifying..."], ["unknown", {}, "Executing..."], ["read_more", {}, "Executing..."]);
+	for (const action of ["send", "ask", "handover"]) cases.push(["intercom", { action }, "Delegating..."]);
+	for (const args of [undefined, null, [], "send", { action: 1 }, { action: "status" }, { action: "receive" }]) cases.push(["intercom", args, "Executing..."]);
+	for (const [name, args, label] of cases) {
+		c.onToolStart(name, "case", args); assert.equal(working.label, label, name); c.onToolEnd("case");
+	}
+});
+
+void test("MCP wrappers explore only exact Context7 documentation selectors", (t) => {
+	t.mock.timers.enable({ apis: ["setInterval"] });
+	const { working, controller: c } = fixture();
+	for (const wrapper of ["mcp", "mcp__context7"]) {
+		for (const tool of ["resolve-library-id", "query-docs", "get-library-docs", "context7_resolve-library-id", "context7_query-docs"]) {
+			c.onToolStart(wrapper, "case", { tool, args: {} });
+			assert.equal(working.label, "Exploring...", `${wrapper}: ${tool}`);
+			c.onToolEnd("case");
+		}
+		for (const args of [undefined, null, [], "query-docs", { tool: null }, { tool: 1 }, { tool: {} }, { tool: ["query-docs"] }, { tool: "" }, { tool: "unknown" }, { tool: "write" }, { tool: "query-docs-more" }, { tool: " QUERY-DOCS" }, { args: { tool: "query-docs" } }, { tool: "mcp", args: { tool: "query-docs" } }, { search: "query-docs" }]) {
+			c.onToolStart(wrapper, "case", args);
+			assert.equal(working.label, "Executing...", `${wrapper}: ${JSON.stringify(args)}`);
+			c.onToolEnd("case");
+		}
+	}
+	c.onToolStart("mcp__other", "case", { tool: "query-docs" });
+	assert.equal(working.label, "Executing...");
+	c.onToolEnd("case");
+});
+
+void test("bash accepts only simple anchored explicit check commands", (t) => {
+	t.mock.timers.enable({ apis: ["setInterval"] });
+	const { working, controller: c } = fixture();
+	for (const command of ["npm test", "npm test -- --runInBand", "npm run test", "npm run lint", "npm run typecheck", "npm run build", "node --test test.ts", "node --test --experimental-strip-types test.ts", "node --experimental-strip-types --test test.ts", "bun test", "npx tsc --noEmit", "npx tsc --noEmit --pretty false", "pytest -q tests", "go test ./...", "  npm test  "]) {
+		c.onToolStart("bash", "case", { command }); assert.equal(working.label, "Verifying...", command); c.onToolEnd("case");
+	}
+	for (const args of [undefined, null, [], "npm test", { command: 1 }, ...["echo npm test", "npm install", "npm run testing", "npm run test:unit", "npx tsc", "node script.js --test", "npm test && echo done", "npm test | cat", "npm test; npm install", "npm test > log", "npm test\necho done", "pytest $(echo tests)", "go test `echo ./...`", "npm test &", "npm test # comment"].map(command => ({ command }))]) {
+		c.onToolStart("bash", "case", args); assert.equal(working.label, "Executing...", JSON.stringify(args)); c.onToolEnd("case");
+	}
+});

package/extensions/osdy-pi/working-controller.ts

@@ -1,21 +1,23 @@
-import type { OsdyState, WorkingWidgetState } from "./types.js";
+import type { OsdyState, WorkingActivity, WorkingWidgetState } from "./types.js";
+import { classifyWorkingActivity, WORKING_ACTIVITY_LABELS } from "./working-activity.js";
 
 export type WorkingController = {
 	onAgentStart(): void;
 	onAgentEnd(): void;
-	onToolStart(toolName: string): void;
-	onToolEnd(): void;
+	onToolStart(toolName: string, toolCallId: string, args?: unknown): void;
+	onToolEnd(toolCallId: string): void;
 	onShutdown(): void;
 	refreshWorking(): void;
 	stopWorking(): void;
 };
 
 export function createWorkingController(
-	state: OsdyState,
+	state: Pick<OsdyState, "enabled">,
 	workingState: WorkingWidgetState,
 ): WorkingController {
 	let activeAgent = false;
-	let activeToolCount = 0;
+	// Map insertion order is start order; duplicate starts must not reorder it.
+	const activeTools = new Map<string, WorkingActivity>();
 
 	const requestWorkingRender = () => workingState.tui?.requestRender();
 	const clearWorkingTimer = () => {
@@ -30,33 +32,31 @@ export function createWorkingController(
 			requestWorkingRender();
 		}, 80);
 	};
-	const setWorkingState = (active: boolean, label: string) => {
-		workingState.active = active;
-		workingState.label = label;
-	};
-	const startWorking = (label: string) => {
-		if (!state.enabled) return;
-		setWorkingState(true, label);
-		ensureWorkingTimer();
-		requestWorkingRender();
+	const setActivity = (activity: WorkingActivity) => {
+		workingState.activity = activity;
+		workingState.label = WORKING_ACTIVITY_LABELS[activity];
 	};
 	const stopWorking = () => {
-		setWorkingState(false, workingState.label);
+		workingState.active = false;
 		clearWorkingTimer();
 		requestWorkingRender();
 	};
-	const getIdleLabel = () =>
-		activeToolCount > 0 ? "Running tool..." : "Working...";
 	const refreshWorking = () => {
-		if (!state.enabled || (!activeAgent && activeToolCount === 0)) {
+		let activity: WorkingActivity = "thinking";
+		for (const remaining of activeTools.values()) activity = remaining;
+		setActivity(activity);
+		if (!state.enabled || (!activeAgent && activeTools.size === 0)) {
 			stopWorking();
 			return;
 		}
-		startWorking(getIdleLabel());
+		workingState.active = true;
+		ensureWorkingTimer();
+		requestWorkingRender();
 	};
 	const resetActivity = () => {
 		activeAgent = false;
-		activeToolCount = 0;
+		activeTools.clear();
+		setActivity("thinking");
 	};
 
 	return {
@@ -68,12 +68,13 @@ export function createWorkingController(
 			resetActivity();
 			refreshWorking();
 		},
-		onToolStart(toolName: string): void {
-			activeToolCount += 1;
-			startWorking(`Running ${toolName}...`);
+		onToolStart(toolName: string, toolCallId: string, args?: unknown): void {
+			if (activeTools.has(toolCallId)) return;
+			activeTools.set(toolCallId, classifyWorkingActivity(toolName, args));
+			refreshWorking();
 		},
-		onToolEnd(): void {
-			activeToolCount = Math.max(0, activeToolCount - 1);
+		onToolEnd(toolCallId: string): void {
+			if (!activeTools.delete(toolCallId)) return;
 			refreshWorking();
 		},
 		onShutdown(): void {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "osdy-pi",
-	"version": "1.11.3",
+	"version": "1.11.4",
 	"description": "Osdy Pi package: themes, header, and custom editor for Pi.",
 	"license": "MIT",
 	"type": "module",
@@ -83,7 +83,7 @@
 		"typescript": "^5.9.3",
 		"typescript-eslint": "^8.46.3"
 	},
-	"releaseSource": "d415942b7668e23c987441a5133f392762b4fe95",
+	"releaseSource": "545560153d13a25f1f0d840878a2a4813df669c0",
 	"repository": {
 		"type": "git",
 		"url": "git+https://github.com/OsdyOrtiz/Osdy-Pi.git"