osdy-pi 1.11.5 → 1.11.7

package/README.md

@@ -488,6 +488,19 @@ While work is active, Osdy Pi centers an activity label and compact animated gly
 | `Delegating...` | ✧ ✦ ✧ | Subagent handoffs. |
 | `Executing...` | ◴ ◷ ◶ ◵ | Unknown or ambiguous tools. |
 
+**Subagent fallback is not live activity.** While a `subagent_run` or `subagent_continue` parent call is active, the indicator distinguishes the two:
+
+| Source | Example | Meaning |
+| --- | --- | --- |
+| Validated public `agent` argument | `explore · Working...` | Generic fallback, not measured progress or a claimed editing operation. This provider-neutral fallback works with Gentle Agents, which currently emits no live child progress. |
+| Public foreground progress from Joker (`pi-subagents-j0k3r`) | `scout · read` | Observable child activity; takes precedence over generic fallback copy. |
+
+The fallback is `<agent> · Working...` regardless of optional `label` metadata; continuations without agent identity use `Subagent`, never an inferred identity. Full tasks, prompts and context are never read or displayed. Model activity uses fixed `Waiting on model` / `Responding` labels, never reasoning or response text.
+
+For multiple running children, the indicator uses the first child in snapshot order with a compact additional-child count. Missing, malformed or no-running-child progress restores the agent's generic fallback, or ordinary parent activity when validated agent identity is unavailable. Labels are bounded, control-safe and clipped to terminal width. Matching tool end, agent/session end and reload cleanup discard per-call state.
+
+**Background limitation:** agent fallbacks appear only while their parent call is active. There is no persistent background live feed, polling or task cache.
+
 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.

package/extensions/osdy-pi/runtime.ts

@@ -1222,6 +1222,9 @@ export async function registerOsdyPi(
 	pi.on("tool_execution_start", (event) =>
 		controller.onToolStart(event.toolName, event.toolCallId, event.args),
 	);
+	pi.on("tool_execution_update", (event) =>
+		controller.onToolUpdate(event.toolName, event.toolCallId, event.partialResult),
+	);
 	pi.on("tool_execution_end", (event, ctx) => {
 		controller.onToolEnd(event.toolCallId);
 		audioRouter.onToolExecutionEnd(event.isError === true, ctx);
@@ -1253,6 +1256,7 @@ export async function registerOsdyPi(
 		sessionContext = undefined;
 	});
 	pi.on("session_start", async (_event, ctx) => {
+		controller.onShutdown();
 		idleUsageRefresh.stop();
 		codexUsageAbort?.abort();
 		codexUsageAbort = undefined;

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

@@ -204,6 +204,14 @@ void test("combining marks and ZWJ emoji remain whole graphemes in the traveling
 	}
 });
 
+void test("compact child labels with wide characters fit the existing renderer", () => {
+	for (const width of [1, 2, 5, 12, 40, 100]) {
+		const current = { ...state("探索👩‍💻 · read (+2)"), activity: "delegating" as const };
+		const line = renderWorkingWidget(current, palette, width)[0] ?? "";
+		assert.ok(visibleWidth(line) <= width, `child label width ${width}`);
+	}
+});
+
 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 activity of activities) {

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

@@ -0,0 +1,68 @@
+import assert from "node:assert/strict";
+import { registerHooks } from "node:module";
+import test from "node:test";
+
+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 { childActivityLabel, childAssignmentLabel: assignment } = await import("./working-child-activity.js");
+
+void test("fallback uses only validated public agent identity regardless of optional label", () => {
+	assert.equal(assignment("subagent_run", { agent: "explore", label: "map footer data" }), "explore · Working...");
+	for (const args of [undefined, null, [], "scout", {}, { agent: 1 }, { agent: "\u0000\n" }, { agent: "a".repeat(4097) }, { label: "secret" }])
+		assert.equal(assignment("subagent_run", args), undefined);
+	for (const label of [undefined, null, 1, [], "", "\u0000", "x".repeat(4097)])
+		assert.equal(assignment("subagent_run", { agent: "scout", label, task: "SECRET", prompt: "SECRET", context: "SECRET" }), "scout · Working...");
+	const metadata = { agent: "scout", get task() { throw new Error("task must not be read"); },
+		get prompt() { throw new Error("prompt must not be read"); }, get context() { throw new Error("context must not be read"); } };
+	assert.equal(assignment("subagent_run", metadata), "scout · Working...");
+	assert.equal(assignment("subagent_run", { agent: "scout" }), "scout · Working...");
+	assert.equal(assignment("read", { agent: "scout", label: "map" }), undefined);
+	assert.equal(assignment("subagent_continue", { id: "scout", label: "resume" }), "Subagent · Working...");
+	assert.equal(assignment("subagent_continue", { agent: 42, label: "resume" }), undefined);
+	assert.equal(assignment("subagent_run", { agent: "\u001b[31m探索\u001b[0m\n\u202eagent", label: "\u001b]0;title\u0007map\t👩‍💻 footer\u0000" }), "探索 agent · Working...");
+	const bounded = assignment("subagent_run", { agent: "🙂".repeat(1000), label: "界".repeat(1000) });
+	assert.equal(Array.from(bounded ?? "").length, 32 + " · Working...".length);
+});
+
+function task(agent = "scout", kind = "tool_running", label = "Reading files", tool_names: unknown = ["read"]) {
+	return { agent, status: "running", live_activity: { current: { kind, label, tool_names } } };
+}
+const progress = (...tasks: unknown[]) => ({ details: { tasks } });
+
+void test("running child shows name and current tool; successive snapshots replace activity", () => {
+	assert.equal(childActivityLabel(progress(task())), "scout · read");
+	assert.equal(childActivityLabel(progress(task("scout", "tool_running", "Checking", ["bash"]))), "scout · bash");
+	assert.equal(childActivityLabel(progress(task("scout", "tool_completed", "Read completed", undefined))), "scout · read (done)");
+	assert.equal(childActivityLabel(progress(task("scout", "tool_failed", "Failed", ["bash"]))), "scout · bash (failed)");
+	assert.equal(childActivityLabel(progress({ agent: "scout", status: "running", live_activity: { current: { kind: "tool_running", label: "UNTRUSTED TEXT" } } })), "scout · Tool running");
+});
+
+void test("multiple children select the first running child in snapshot order with bounded count", () => {
+	assert.equal(childActivityLabel(progress({ agent: "old", status: "completed" }, task("first"), task("second"), task("third"))), "first · read (+2)");
+	assert.equal(childActivityLabel(progress(...Array.from({ length: 65 }, () => task()))), undefined);
+});
+
+void test("terminal, missing, malformed and unsupported progress falls back", () => {
+	for (const status of ["completed", "failed", "cancelled", "aborted", "pending", "interrupted", "stopping", "queued"]) {
+		assert.equal(childActivityLabel(progress({ ...task(), status })), undefined);
+	}
+	for (const value of [undefined, null, [], {}, { details: null }, { details: { tasks: {} } }, progress(), progress(null), progress({ ...task(), agent: 1 }), progress({ ...task(), status: "unknown" }), progress({ agent: "scout", status: "running" }), progress(task("scout", "unknown")), progress(task("scout", "tool_running", "Read", [1]))]) {
+		assert.equal(childActivityLabel(value), undefined, JSON.stringify(value));
+	}
+});
+
+void test("model activity never exposes thinking labels or response text", () => {
+	assert.equal(childActivityLabel(progress(task("scout", "thinking", "PRIVATE REASONING"))), "scout · Waiting on model");
+	assert.equal(childActivityLabel(progress(task("scout", "streaming_response", "PRIVATE RESPONSE"))), "scout · Responding");
+});
+
+void test("external labels are single-line, control-free and bounded", () => {
+	const dirty = "\u001b[31mAgent\u001b[0m\n\t\u202eName\u0007";
+	assert.equal(childActivityLabel(progress(task(dirty, "tool_running", "unused", ["\u001b]0;title\u0007read\nfile"]))), "Agent Name · read file");
+	const label = childActivityLabel(progress(task("a".repeat(1000), "tool_running", "unused", ["b".repeat(1000)])));
+	assert.ok(label && label.length <= 100);
+	assert.equal(childActivityLabel(progress(task("\u0000\n"))), undefined);
+});

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

@@ -0,0 +1,66 @@
+import { stripVTControlCharacters } from "node:util";
+
+function record(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+/** Bound untrusted metadata before rendering; retain ZWJ emoji, never terminal controls. */
+function safeLabel(value: unknown, limit: number): string | undefined {
+	if (typeof value !== "string" || value.length > 4096) return undefined;
+	const clean = stripVTControlCharacters(value)
+		.replace(/[\p{Cc}\p{Cf}]/gu, character => character === "\u200d" ? character : " ")
+		.replace(/\s+/gu, " ").trim();
+	return Array.from(clean).slice(0, limit).join("") || undefined;
+}
+
+/** Assignment only: never infer activity or identity from task, prompt or context. */
+export function childAssignmentLabel(toolName: string, args: unknown): string | undefined {
+	if (toolName !== "subagent_run" && toolName !== "subagent_continue") return undefined;
+	if (!record(args)) return undefined;
+	const agent = args.agent === undefined && toolName === "subagent_continue" ? "Subagent" : safeLabel(args.agent, 32);
+	if (!agent) return undefined;
+	return `${agent} · Working...`;
+}
+
+function observableActivity(value: unknown): string | undefined {
+	if (!record(value) || typeof value.label !== "string") return undefined;
+	// Ignore model labels: they may contain response text or imply access to reasoning.
+	if (value.kind === "thinking") return "Waiting on model";
+	if (value.kind === "streaming_response") return "Responding";
+	if (value.kind !== "tool_running" && value.kind !== "tool_completed" && value.kind !== "tool_failed") return undefined;
+	let tool = "Tool";
+	if (value.tool_names !== undefined) {
+		if (!Array.isArray(value.tool_names) || value.tool_names.length > 16) return undefined;
+		const names: string[] = [];
+		for (const name of value.tool_names) {
+			const safe = safeLabel(name, 40);
+			if (!safe) return undefined;
+			names.push(safe);
+		}
+		tool = names[0] ?? tool;
+	}
+	if (value.kind === "tool_completed") return `${tool} (done)`;
+	if (value.kind === "tool_failed") return `${tool} (failed)`;
+	return tool === "Tool" ? "Tool running" : tool;
+}
+
+/** Consume only public foreground metadata, not content, trails or transcripts. */
+export function childActivityLabel(partialResult: unknown): string | undefined {
+	if (!record(partialResult) || !record(partialResult.details)) return undefined;
+	const tasks: unknown = partialResult.details.tasks;
+	if (!Array.isArray(tasks) || tasks.length > 64) return undefined;
+	let first: string | undefined;
+	let running = 0;
+	for (const task of tasks) {
+		if (!record(task) || typeof task.status !== "string") return undefined;
+		if (task.status !== "running") continue;
+		const agent = safeLabel(task.agent, 32);
+		const activity = record(task.live_activity) ? observableActivity(task.live_activity.current) : undefined;
+		if (!agent || !activity) return undefined;
+		first ??= `${agent} · ${activity}`;
+		running++;
+	}
+	if (!first) return undefined;
+	if (running > 1) return `${first} (+${running - 1})`;
+	return first;
+}

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

@@ -103,6 +103,110 @@ void test("MCP wrappers explore only exact Context7 documentation selectors", (t
 	c.onToolEnd("case");
 });
 
+const childProgress = (agent: string, tool = "read", status = "running") => ({ details: { tasks: [
+	{ agent, status, live_activity: { current: { kind: "tool_running", label: "Reading", tool_names: [tool] } } },
+] } });
+
+void test("child updates respect tool identity and latest remaining tool ownership", (t) => {
+	t.mock.timers.enable({ apis: ["setInterval"] });
+	const { working, controller: c } = fixture();
+	c.onToolStart("subagent_run", "a");
+	c.onToolUpdate("subagent_run", "a", childProgress("scout"));
+	assert.equal(working.label, "scout · read");
+	c.onToolStart("subagent_run", "b");
+	c.onToolUpdate("subagent_run", "b", childProgress("writer", "edit"));
+	c.onToolUpdate("subagent_run", "a", childProgress("scout", "grep"));
+	c.onToolUpdate("read", "b", childProgress("wrong"));
+	c.onToolUpdate("subagent_run", "missing", childProgress("late"));
+	c.onToolEnd("missing");
+	assert.equal(working.label, "writer · edit");
+	c.onToolStart("read", "ordinary");
+	c.onToolUpdate("subagent_run", "ordinary", childProgress("wrong"));
+	assert.equal(working.label, "Exploring...");
+	c.onToolEnd("ordinary"); assert.equal(working.label, "writer · edit");
+	c.onToolEnd("b"); assert.equal(working.label, "scout · grep");
+	c.onToolUpdate("subagent_run", "b", childProgress("late"));
+	assert.equal(working.label, "scout · grep");
+	c.onToolUpdate("subagent_run", "a", childProgress("scout", "read", "completed"));
+	assert.equal(working.label, "Delegating...");
+	c.onToolUpdate("subagent_run", "a", childProgress("scout"));
+	c.onToolUpdate("subagent_run", "a", { details: { tasks: null } });
+	assert.equal(working.label, "Delegating...");
+	c.onToolEnd("a"); assert.equal(working.active, false);
+});
+
+void test("agent/session disposal clears child progress and rejects late updates", (t) => {
+	t.mock.timers.enable({ apis: ["setInterval"] });
+	const { working, controller: c } = fixture();
+	for (const cleanup of [() => c.onAgentEnd(), () => c.onShutdown()]) {
+		c.onToolStart("subagent_run", "a");
+		c.onToolUpdate("subagent_run", "a", childProgress("scout"));
+		cleanup();
+		c.onToolUpdate("subagent_run", "a", childProgress("late"));
+		assert.equal(working.active, false); assert.equal(working.label, "Thinking...");
+		assert.equal(working.timer, undefined);
+		c.onAgentStart(); assert.equal(working.label, "Thinking...");
+		c.onAgentEnd();
+	}
+});
+
+void test("agent fallback appears at start and resets after unavailable, malformed or terminal live progress", (t) => {
+	t.mock.timers.enable({ apis: ["setInterval"] });
+	const { working, controller: c } = fixture();
+	c.onToolStart("subagent_run", "a", { agent: "explore", label: "map footer data", task: "SECRET TASK", prompt: "SECRET PROMPT" });
+	assert.equal(working.label, "explore · Working...");
+	c.onToolUpdate("subagent_run", "a", childProgress("explore"));
+	assert.equal(working.label, "explore · read");
+	for (const update of [undefined, {}, { details: { tasks: null } }, { details: { tasks: [{ agent: "explore", status: "running" }] } }, childProgress("explore", "read", "completed")]) {
+		c.onToolUpdate("subagent_run", "a", childProgress("explore"));
+		assert.equal(working.label, "explore · read");
+		c.onToolUpdate("subagent_run", "a", update);
+		assert.equal(working.label, "explore · Working...");
+	}
+	c.onToolEnd("a"); assert.equal(working.label, "Thinking...");
+});
+
+void test("continuations use generic identity without guessing and preserve call ownership", (t) => {
+	t.mock.timers.enable({ apis: ["setInterval"] });
+	const { working, controller: c } = fixture();
+	c.onToolStart("subagent_run", "a", { agent: "scout" });
+	assert.equal(working.label, "scout · Working...");
+	c.onToolStart("subagent_continue", "b", { id: "a", label: "check footer" });
+	assert.equal(working.label, "Subagent · Working...");
+	c.onToolStart("subagent_continue", "a", { agent: "wrong", label: "wrong" });
+	c.onToolUpdate("subagent_run", "b", childProgress("wrong"));
+	c.onToolUpdate("subagent_continue", "missing", childProgress("wrong"));
+	assert.equal(working.label, "Subagent · Working...");
+	c.onToolUpdate("subagent_continue", "b", childProgress("writer", "edit"));
+	assert.equal(working.label, "writer · edit");
+	c.onToolUpdate("subagent_run", "a", childProgress("scout"));
+	assert.equal(working.label, "writer · edit");
+	c.onToolUpdate("subagent_continue", "b", {});
+	assert.equal(working.label, "Subagent · Working...");
+	c.onToolEnd("b"); assert.equal(working.label, "scout · read");
+	c.onToolUpdate("subagent_continue", "b", childProgress("late"));
+	c.onToolUpdate("subagent_run", "a", {}); assert.equal(working.label, "scout · Working...");
+	c.onToolEnd("a");
+	c.onToolStart("subagent_continue", "c", { agent: "writer", label: "finish" });
+	assert.equal(working.label, "writer · Working...");
+	c.onToolEnd("c");
+	c.onToolStart("subagent_continue", "d", { id: "c", task: "SECRET" });
+	assert.equal(working.label, "Subagent · Working...");
+	c.onToolEnd("d");
+});
+
+void test("assignment metadata is cleared on agent and session cleanup", (t) => {
+	t.mock.timers.enable({ apis: ["setInterval"] });
+	const { working, controller: c } = fixture();
+	for (const cleanup of [() => c.onAgentEnd(), () => c.onShutdown()]) {
+		c.onToolStart("subagent_run", "a", { agent: "scout", label: "map" });
+		assert.equal(working.label, "scout · Working...");
+		cleanup(); c.onToolUpdate("subagent_run", "a", childProgress("late"));
+		c.refreshWorking(); assert.equal(working.label, "Thinking...");
+		assert.equal(working.active, false); assert.equal(working.timer, undefined);
+	}
+});
+
 void test("bash accepts only simple anchored explicit check commands", (t) => {
 	t.mock.timers.enable({ apis: ["setInterval"] });
 	const { working, controller: c } = fixture();

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

@@ -1,10 +1,12 @@
 import type { OsdyState, WorkingActivity, WorkingWidgetState } from "./types.js";
 import { classifyWorkingActivity, WORKING_ACTIVITY_LABELS } from "./working-activity.js";
+import { childActivityLabel, childAssignmentLabel } from "./working-child-activity.js";
 
 export type WorkingController = {
 	onAgentStart(): void;
 	onAgentEnd(): void;
 	onToolStart(toolName: string, toolCallId: string, args?: unknown): void;
+	onToolUpdate(toolName: string, toolCallId: string, partialResult: unknown): void;
 	onToolEnd(toolCallId: string): void;
 	onShutdown(): void;
 	refreshWorking(): void;
@@ -17,7 +19,8 @@ export function createWorkingController(
 ): WorkingController {
 	let activeAgent = false;
 	// Map insertion order is start order; duplicate starts must not reorder it.
-	const activeTools = new Map<string, WorkingActivity>();
+	type ActiveTool = { activity: WorkingActivity; toolName: string; childLabel: string | undefined; assignmentLabel: string | undefined };
+	const activeTools = new Map<string, ActiveTool>();
 
 	const requestWorkingRender = () => workingState.tui?.requestRender();
 	const clearWorkingTimer = () => {
@@ -42,9 +45,11 @@ export function createWorkingController(
 		requestWorkingRender();
 	};
 	const refreshWorking = () => {
-		let activity: WorkingActivity = "thinking";
-		for (const remaining of activeTools.values()) activity = remaining;
-		setActivity(activity);
+		let current: ActiveTool | undefined;
+		for (const remaining of activeTools.values()) current = remaining;
+		setActivity(current?.activity ?? "thinking");
+		const label = current?.childLabel ?? current?.assignmentLabel;
+		if (label) workingState.label = label;
 		if (!state.enabled || (!activeAgent && activeTools.size === 0)) {
 			stopWorking();
 			return;
@@ -70,7 +75,14 @@ export function createWorkingController(
 		},
 		onToolStart(toolName: string, toolCallId: string, args?: unknown): void {
 			if (activeTools.has(toolCallId)) return;
-			activeTools.set(toolCallId, classifyWorkingActivity(toolName, args));
+			activeTools.set(toolCallId, { activity: classifyWorkingActivity(toolName, args), toolName,
+				childLabel: undefined, assignmentLabel: childAssignmentLabel(toolName, args) });
+			refreshWorking();
+		},
+		onToolUpdate(toolName: string, toolCallId: string, partialResult: unknown): void {
+			const tool = activeTools.get(toolCallId);
+			if ((toolName !== "subagent_run" && toolName !== "subagent_continue") || tool?.toolName !== toolName) return;
+			tool.childLabel = childActivityLabel(partialResult);
 			refreshWorking();
 		},
 		onToolEnd(toolCallId: string): void {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "osdy-pi",
-	"version": "1.11.5",
+	"version": "1.11.7",
 	"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": "312ca263d7eaa2a151db46121380b97fc60f0831",
+	"releaseSource": "fa08213880378e71ddcadea11cd71da3406d7cf6",
 	"repository": {
 		"type": "git",
 		"url": "git+https://github.com/OsdyOrtiz/Osdy-Pi.git"