osdy-pi 1.11.7 → 1.11.9

package/README.md

@@ -492,12 +492,14 @@ While work is active, Osdy Pi centers an activity label and compact animated gly
 
 | 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. |
+| Validated public `agent` argument | `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`) | `Exploring...` | Named `read` activity selects both the Exploring label and its existing glyph frames, overriding fallback. |
 
-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.
+Live child activity uses the same six states and corresponding animated glyphs listed above, without agent names: `Thinking...`, `Exploring...`, `Verifying...`, `Working...`, `Delegating...`, or `Executing...`. Both public thinking and response streaming select Thinking; model labels, reasoning and response text are never read. Named reads/searches/direct documentation tools select Exploring, `lens_diagnostics` selects Verifying, edits/writes select Working, and `subagent_run` selects Delegating. Only named checks qualify: public tool metadata lacks arguments, so `bash`, wrappers needing selectors, and unknown tool names select Executing. Tool completion/failure events classify the reported operation while the child is running; they do not claim whole-task completion.
 
-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.
+The fallback is `Working...` **with the Working glyph**, regardless of optional `label` metadata. Missing or empty tool names supply no usable operation; named unknown tools instead select Executing. A continuation with an absent agent validates the generic `Subagent` identity without displaying it, never inferring an identity; missing/invalid run identity or explicitly invalid continuation identity fails closed to ordinary parent activity unless a live snapshot supplies its own validated public agent. Full tasks, prompts, context, content, trails and transcripts are never read or displayed.
+
+For multiple running children, the indicator uses the first child in snapshot order with a compact additional-child count (`(+N)`). Missing, malformed, terminal or no-running-child progress restores both the generic `Working...` fallback text and Working glyph, 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.
 

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

@@ -1,68 +1,105 @@
 import assert from "node:assert/strict";
 import { registerHooks } from "node:module";
 import test from "node:test";
+import type { WorkingActivity } 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 { childActivityLabel, childAssignmentLabel: assignment } = await import("./working-child-activity.js");
+const { childActivityState: activity, childAssignmentState: assignment } = await import("./working-child-activity.js");
+const working = () => ({ activity: "working", label: "Working..." });
 
 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...");
+	assert.deepEqual(assignment("subagent_run", { agent: "explore", label: "map footer data" }), 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);
+		assert.deepEqual(assignment("subagent_run", { agent: "scout", label, task: "SECRET", prompt: "SECRET", context: "SECRET" }), working());
+	const metadata = { agent: "scout", get label() { throw new Error("label must not be read"); },
+		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.deepEqual(assignment("subagent_run", metadata), working());
+	assert.equal(assignment("read", { agent: "scout" }), undefined);
+	assert.deepEqual(assignment("subagent_continue", { id: "scout" }), working());
+	for (const agent of [42, null, "", "\u0000"])
+		assert.equal(assignment("subagent_continue", { agent }), undefined);
+	assert.deepEqual(assignment("subagent_run", { agent: "\u001b[31m探索\u001b[0m\n\u202eagent" }), working());
+	assert.deepEqual(assignment("subagent_run", { agent: "🙂".repeat(1000) }), working());
 });
 
-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 } } };
+function task(agent = "scout", kind = "tool_running", tool_names: unknown = ["read"]) {
+	return { agent, status: "running", live_activity: { current: { kind, tool_names,
+		get label() { throw new Error("model label must not be read"); },
+		get thinking() { throw new Error("thinking must not be read"); },
+		get content() { throw new Error("content must not be read"); },
+		get response() { throw new Error("response must not be read"); } },
+		get trail() { throw new Error("trail must not be read"); } },
+		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"); },
+		get transcript() { throw new Error("transcript must not be read"); } };
 }
 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("public operations return structured six-state activity and label", () => {
+	const cases: Array<[string, WorkingActivity, string]> = [
+		["read", "exploring", "Exploring..."], ["grep", "exploring", "Exploring..."],
+		["query-docs", "exploring", "Exploring..."], ["lens_diagnostics", "verifying", "Verifying..."],
+		["edit", "working", "Working..."], ["write", "working", "Working..."],
+		["subagent_run", "delegating", "Delegating..."], ["unknown", "executing", "Executing..."],
+		["bash", "executing", "Executing..."], ["mcp", "executing", "Executing..."],
+		["mcp__context7", "executing", "Executing..."], ["intercom", "executing", "Executing..."],
+	];
+	for (const kind of ["tool_running", "tool_completed", "tool_failed"])
+		for (const [tool, state, label] of cases)
+			assert.deepEqual(activity(progress(task("scout", kind, [tool]))), { activity: state, label });
+	for (const kind of ["thinking", "streaming_response"])
+		assert.deepEqual(activity(progress(task("scout", kind))), { activity: "thinking", label: "Thinking..." });
 });
 
-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("multiple children select first running snapshot child and validate all children", () => {
+	assert.deepEqual(activity(progress({ agent: "old", status: "completed" }, task("first"), task("second"), task("third"))),
+		{ activity: "exploring", label: "Exploring... (+2)" });
+	assert.deepEqual(activity(progress(task("first", "tool_running", ["read", "write"]))), { activity: "exploring", label: "Exploring..." });
+	assert.equal(activity(progress(task(), task("bad", "tool_running", ["read", 1]))), undefined);
+	assert.equal(activity(progress(...Array.from({ length: 65 }, () => task()))), undefined);
+	assert.equal(activity(progress(...Array.from({ length: 64 }, () => task())))?.label, "Exploring... (+63)");
 });
 
-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("terminal, missing, malformed and unsupported progress has no usable activity", () => {
+	for (const status of ["completed", "failed", "cancelled", "aborted", "pending", "interrupted", "stopping", "queued", "unknown"]) {
+		const child = task();
+		child.status = status;
+		assert.equal(activity(progress(child)), undefined);
 	}
+	for (const value of [undefined, null, [], {}, { details: null }, { details: { tasks: {} } }, progress(), progress(null),
+		progress({ agent: 1, status: "running" }), progress({ agent: "scout", status: "running" }), progress(task("scout", "unknown"))])
+		assert.equal(activity(value), undefined);
+	for (const tool_names of [undefined, [], [""], ["\u0000"], [1], "read", ["read", null], Array(17).fill("read"), ["x".repeat(4097)]])
+		assert.equal(activity(progress({ agent: "scout", status: "running", live_activity: { current: { kind: "tool_running", tool_names } } })), undefined);
+	assert.equal(activity(progress(task("scout", "tool_running", Array(16).fill("read"))))?.activity, "exploring");
+});
+
+void test("non-string snapshot agent is rejected despite otherwise valid live activity", () => {
+	assert.equal(activity(progress(Object.assign(task(), { agent: 1 }))), undefined);
+});
+
+void test("oversized snapshot agent is rejected despite otherwise valid live activity", () => {
+	assert.equal(activity(progress(task("a".repeat(4097)))), undefined);
 });
 
-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("snapshot agent at the input bound remains valid without appearing in the label", () => {
+	assert.deepEqual(activity(progress(task("a".repeat(4096)))),
+		{ activity: "exploring", label: "Exploring..." });
 });
 
-void test("external labels are single-line, control-free and bounded", () => {
+void test("external names are single-line, control-free and bounded before classification", () => {
 	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);
+	assert.deepEqual(activity(progress(task(dirty, "tool_running", ["\u001b]0;title\u0007read\nfile"]))),
+		{ activity: "executing", label: "Executing..." });
+	assert.deepEqual(activity(progress(task("a".repeat(1000), "tool_running", ["b".repeat(1000)]))),
+		{ activity: "executing", label: "Executing..." });
+	assert.equal(activity(progress(task("\u0000\n"))), undefined);
 });

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

@@ -1,4 +1,12 @@
 import { stripVTControlCharacters } from "node:util";
+import type { WorkingActivity } from "./types.js";
+import { classifyWorkingActivity, WORKING_ACTIVITY_LABELS } from "./working-activity.js";
+
+export type ChildWorkingState = { activity: WorkingActivity; label: string };
+
+function childState(activity: WorkingActivity): ChildWorkingState {
+	return { activity, label: WORKING_ACTIVITY_LABELS[activity] };
+}
 
 function record(value: unknown): value is Record<string, unknown> {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -14,21 +22,20 @@ function safeLabel(value: unknown, limit: number): string | undefined {
 }
 
 /** Assignment only: never infer activity or identity from task, prompt or context. */
-export function childAssignmentLabel(toolName: string, args: unknown): string | undefined {
+export function childAssignmentState(toolName: string, args: unknown): ChildWorkingState | 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...`;
+	return childState("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";
+function observableActivity(value: unknown): WorkingActivity | undefined {
+	if (!record(value)) return undefined;
+	// Do not even access model labels: they may expose private response or reasoning text.
+	if (value.kind === "thinking" || value.kind === "streaming_response") return "thinking";
 	if (value.kind !== "tool_running" && value.kind !== "tool_completed" && value.kind !== "tool_failed") return undefined;
-	let tool = "Tool";
+	let tool: string | undefined;
 	if (value.tool_names !== undefined) {
 		if (!Array.isArray(value.tool_names) || value.tool_names.length > 16) return undefined;
 		const names: string[] = [];
@@ -37,19 +44,18 @@ function observableActivity(value: unknown): string | undefined {
 			if (!safe) return undefined;
 			names.push(safe);
 		}
-		tool = names[0] ?? tool;
+		tool = names[0];
 	}
-	if (value.kind === "tool_completed") return `${tool} (done)`;
-	if (value.kind === "tool_failed") return `${tool} (failed)`;
-	return tool === "Tool" ? "Tool running" : tool;
+	// Public snapshots provide names only; never invent command or wrapper selectors.
+	return tool === undefined ? undefined : classifyWorkingActivity(tool, undefined);
 }
 
 /** Consume only public foreground metadata, not content, trails or transcripts. */
-export function childActivityLabel(partialResult: unknown): string | undefined {
+export function childActivityState(partialResult: unknown): ChildWorkingState | 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 first: ChildWorkingState | undefined;
 	let running = 0;
 	for (const task of tasks) {
 		if (!record(task) || typeof task.status !== "string") return undefined;
@@ -57,10 +63,10 @@ export function childActivityLabel(partialResult: unknown): string | undefined {
 		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}`;
+		first ??= childState(activity);
 		running++;
 	}
 	if (!first) return undefined;
-	if (running > 1) return `${first} (+${running - 1})`;
+	if (running > 1) return { ...first, label: `${first.label} (+${running - 1})` };
 	return first;
 }

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

@@ -1,7 +1,7 @@
 import assert from "node:assert/strict";
 import { registerHooks } from "node:module";
 import test from "node:test";
-import type { WorkingWidgetState } from "./types.js";
+import type { WorkingActivity, WorkingWidgetState } from "./types.js";
 
 registerHooks({ resolve(specifier, context, nextResolve) {
 	if (specifier.startsWith(".") && specifier.endsWith(".js") && context.parentURL?.endsWith(".ts"))
@@ -9,6 +9,17 @@ registerHooks({ resolve(specifier, context, nextResolve) {
 	return nextResolve(specifier, context);
 } });
 const { createWorkingController } = await import("./working-controller.js");
+const { renderWorkingWidget } = await import("./working-animation.js");
+const { WORKING_ACTIVITY_FRAMES } = await import("./constants.js");
+
+function assertDisplay(working: WorkingWidgetState, activity: WorkingActivity, label: string): void {
+	assert.equal(working.activity, activity);
+	assert.equal(working.label, label);
+	for (let frame = 0; frame < WORKING_ACTIVITY_FRAMES[activity].length; frame++) {
+		const line = renderWorkingWidget({ ...working, frame }, { fg: (_color, text) => text }, 100)[0];
+		assert.equal(line?.trim(), `${WORKING_ACTIVITY_FRAMES[activity][frame]} ${label}`);
+	}
+}
 
 function fixture() {
 	const state = { enabled: true };
@@ -107,26 +118,48 @@ const childProgress = (agent: string, tool = "read", status = "running") => ({ d
 	{ agent, status, live_activity: { current: { kind: "tool_running", label: "Reading", tool_names: [tool] } } },
 ] } });
 
+void test("child states select matching text and every existing glyph frame", (t) => {
+	t.mock.timers.enable({ apis: ["setInterval"] });
+	const { working, controller: c } = fixture();
+	c.onToolStart("subagent_run", "child", { agent: "scout" });
+	assertDisplay(working, "working", "Working...");
+	const cases: Array<[string, string | undefined, WorkingActivity, string]> = [
+		["thinking", undefined, "thinking", "Thinking..."],
+		["streaming_response", undefined, "thinking", "Thinking..."],
+		["tool_running", "read", "exploring", "Exploring..."],
+		["tool_completed", "lens_diagnostics", "verifying", "Verifying..."],
+		["tool_failed", "write", "working", "Working..."],
+		["tool_running", "subagent_run", "delegating", "Delegating..."],
+		["tool_running", "unknown", "executing", "Executing..."],
+	];
+	for (const [kind, tool, activity, label] of cases) {
+		c.onToolUpdate("subagent_run", "child", { details: { tasks: [{ agent: "scout", status: "running",
+			live_activity: { current: { kind, label: "IGNORED", tool_names: tool ? [tool] : undefined } } }] } });
+		assertDisplay(working, activity, label);
+	}
+	c.onShutdown();
+});
+
 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");
+	assertDisplay(working, "exploring", "Exploring...");
 	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");
+	assertDisplay(working, "working", "Working...");
 	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.onToolEnd("ordinary"); assertDisplay(working, "working", "Working...");
+	c.onToolEnd("b"); assertDisplay(working, "exploring", "Exploring...");
 	c.onToolUpdate("subagent_run", "b", childProgress("late"));
-	assert.equal(working.label, "scout · grep");
+	assertDisplay(working, "exploring", "Exploring...");
 	c.onToolUpdate("subagent_run", "a", childProgress("scout", "read", "completed"));
 	assert.equal(working.label, "Delegating...");
 	c.onToolUpdate("subagent_run", "a", childProgress("scout"));
@@ -154,14 +187,16 @@ void test("agent fallback appears at start and resets after unavailable, malform
 	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...");
+	assertDisplay(working, "working", "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")]) {
+	assertDisplay(working, "exploring", "Exploring...");
+	for (const update of [undefined, {}, { details: { tasks: null } }, { details: { tasks: [{ agent: "explore", status: "running" }] } }, childProgress("explore", "read", "completed"), childProgress("explore", ""),
+		{ details: { tasks: [{ agent: "explore", status: "running", live_activity: { current: { kind: "tool_running", tool_names: [] } } }] } },
+		{ details: { tasks: [{ agent: "explore", status: "running", live_activity: { current: { kind: "tool_running" } } }] } }]) {
 		c.onToolUpdate("subagent_run", "a", childProgress("explore"));
-		assert.equal(working.label, "explore · read");
+		assertDisplay(working, "exploring", "Exploring...");
 		c.onToolUpdate("subagent_run", "a", update);
-		assert.equal(working.label, "explore · Working...");
+		assertDisplay(working, "working", "Working...");
 	}
 	c.onToolEnd("a"); assert.equal(working.label, "Thinking...");
 });
@@ -170,37 +205,67 @@ void test("continuations use generic identity without guessing and preserve call
 	t.mock.timers.enable({ apis: ["setInterval"] });
 	const { working, controller: c } = fixture();
 	c.onToolStart("subagent_run", "a", { agent: "scout" });
-	assert.equal(working.label, "scout · Working...");
+	assert.equal(working.label, "Working...");
 	c.onToolStart("subagent_continue", "b", { id: "a", label: "check footer" });
-	assert.equal(working.label, "Subagent · Working...");
+	assert.equal(working.label, "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...");
+	assert.equal(working.label, "Working...");
 	c.onToolUpdate("subagent_continue", "b", childProgress("writer", "edit"));
-	assert.equal(working.label, "writer · edit");
+	assertDisplay(working, "working", "Working...");
 	c.onToolUpdate("subagent_run", "a", childProgress("scout"));
-	assert.equal(working.label, "writer · edit");
+	assertDisplay(working, "working", "Working...");
 	c.onToolUpdate("subagent_continue", "b", {});
-	assert.equal(working.label, "Subagent · Working...");
-	c.onToolEnd("b"); assert.equal(working.label, "scout · read");
+	assert.equal(working.label, "Working...");
+	c.onToolEnd("b"); assertDisplay(working, "exploring", "Exploring...");
 	c.onToolUpdate("subagent_continue", "b", childProgress("late"));
-	c.onToolUpdate("subagent_run", "a", {}); assert.equal(working.label, "scout · Working...");
+	c.onToolUpdate("subagent_run", "a", {}); assert.equal(working.label, "Working...");
 	c.onToolEnd("a");
 	c.onToolStart("subagent_continue", "c", { agent: "writer", label: "finish" });
-	assert.equal(working.label, "writer · Working...");
+	assert.equal(working.label, "Working...");
 	c.onToolEnd("c");
 	c.onToolStart("subagent_continue", "d", { id: "c", task: "SECRET" });
-	assert.equal(working.label, "Subagent · Working...");
+	assert.equal(working.label, "Working...");
 	c.onToolEnd("d");
 });
 
+void test("identity failures stay parent-owned and live snapshots retain validated public identity", (t) => {
+	t.mock.timers.enable({ apis: ["setInterval"] });
+	const { working, controller: c } = fixture();
+	for (const args of [undefined, {}, { agent: null }, { agent: "" }]) {
+		c.onToolStart("subagent_run", "run", args);
+		assertDisplay(working, "delegating", "Delegating...");
+		c.onToolUpdate("subagent_run", "run", childProgress("public"));
+		assertDisplay(working, "exploring", "Exploring...");
+		c.onToolUpdate("subagent_run", "run", {});
+		assertDisplay(working, "delegating", "Delegating...");
+		c.onToolEnd("run");
+	}
+	c.onToolStart("subagent_continue", "continue", { agent: null });
+	assertDisplay(working, "executing", "Executing...");
+	c.onToolEnd("continue");
+	c.onToolStart("subagent_continue", "continue", {});
+	assertDisplay(working, "working", "Working...");
+	c.onToolUpdate("subagent_continue", "continue", { details: { tasks: [
+		{ agent: "first", status: "running", live_activity: { current: { kind: "tool_running", tool_names: ["read"] } } },
+		{ agent: "second", status: "running", live_activity: { current: { kind: "thinking" } } },
+	] } });
+	assertDisplay(working, "exploring", "Exploring... (+1)");
+	c.onToolStart("subagent_run", "continue", { agent: "wrong" });
+	c.onToolUpdate("subagent_run", "continue", childProgress("wrong"));
+	assertDisplay(working, "exploring", "Exploring... (+1)");
+	c.onToolUpdate("subagent_continue", "continue", {});
+	assertDisplay(working, "working", "Working...");
+	c.onShutdown();
+});
+
 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...");
+		assert.equal(working.label, "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);

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

@@ -1,6 +1,6 @@
 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";
+import { childActivityState, childAssignmentState, type ChildWorkingState } from "./working-child-activity.js";
 
 export type WorkingController = {
 	onAgentStart(): void;
@@ -19,7 +19,12 @@ export function createWorkingController(
 ): WorkingController {
 	let activeAgent = false;
 	// Map insertion order is start order; duplicate starts must not reorder it.
-	type ActiveTool = { activity: WorkingActivity; toolName: string; childLabel: string | undefined; assignmentLabel: string | undefined };
+	type ActiveTool = {
+		activity: WorkingActivity;
+		toolName: string;
+		childState: ChildWorkingState | undefined;
+		assignmentState: ChildWorkingState | undefined;
+	};
 	const activeTools = new Map<string, ActiveTool>();
 
 	const requestWorkingRender = () => workingState.tui?.requestRender();
@@ -47,9 +52,9 @@ export function createWorkingController(
 	const refreshWorking = () => {
 		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;
+		const child = current?.childState ?? current?.assignmentState;
+		setActivity(child?.activity ?? current?.activity ?? "thinking");
+		if (child) workingState.label = child.label;
 		if (!state.enabled || (!activeAgent && activeTools.size === 0)) {
 			stopWorking();
 			return;
@@ -76,13 +81,13 @@ export function createWorkingController(
 		onToolStart(toolName: string, toolCallId: string, args?: unknown): void {
 			if (activeTools.has(toolCallId)) return;
 			activeTools.set(toolCallId, { activity: classifyWorkingActivity(toolName, args), toolName,
-				childLabel: undefined, assignmentLabel: childAssignmentLabel(toolName, args) });
+				childState: undefined, assignmentState: childAssignmentState(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);
+			tool.childState = childActivityState(partialResult);
 			refreshWorking();
 		},
 		onToolEnd(toolCallId: string): void {

package/package.json

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