osdy-pi 1.11.6 → 1.11.8

package/README.md

@@ -488,18 +488,20 @@ While work is active, Osdy Pi centers an activity label and compact animated gly
 | `Delegating...` | ✧ ✦ ✧ | Subagent handoffs. |
 | `Executing...` | ◴ ◷ ◶ ◵ | Unknown or ambiguous tools. |
 
-**Subagent assignment is not live activity.** While a `subagent_run` or `subagent_continue` parent call is active, the indicator distinguishes the two:
+**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` and optional `label` arguments | `explore · Task: map footer data` | Submitted assignment, not a claimed tool 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 assignment copy. |
+| 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 · Exploring...` | Named `read` activity selects both the Exploring label and its existing glyph frames, overriding fallback. |
 
-Without a usable label, assignment copy is `Task assigned`; 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, retaining the agent prefix: `scout · 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 assignment, or ordinary parent activity when assignment metadata 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 `<agent> · 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 uses `Subagent`, never an inferred 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.
 
-**Background limitation:** assignments appear only while their parent call is active. There is no persistent background live feed, polling or task cache.
+For multiple running children, the indicator uses the first child in snapshot order with a compact additional-child count. Missing, malformed, terminal or no-running-child progress restores both the agent's generic 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.
 
 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.
 

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

@@ -1,67 +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 = (agent: string) => ({ activity: "working", label: `${agent} · Working...` });
 
-void test("assignment uses only validated public agent and label metadata", () => {
-	assert.equal(assignment("subagent_run", { agent: "explore", label: "map footer data" }), "explore · Task: map footer data");
+void test("fallback uses only validated public agent identity regardless of optional label", () => {
+	assert.deepEqual(assignment("subagent_run", { agent: "explore", label: "map footer data" }), working("explore"));
 	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 · Task assigned");
-	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 · Task assigned");
-	assert.equal(assignment("read", { agent: "scout", label: "map" }), undefined);
-	assert.equal(assignment("subagent_continue", { id: "scout", label: "resume" }), "Subagent · Task: resume");
-	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 · Task: map 👩‍💻 footer");
-	const bounded = assignment("subagent_run", { agent: "🙂".repeat(1000), label: "界".repeat(1000) });
-	assert.equal(Array.from(bounded ?? "").length, 32 + " · Task: ".length + 80);
+		assert.deepEqual(assignment("subagent_run", { agent: "scout", label, task: "SECRET", prompt: "SECRET", context: "SECRET" }), working("scout"));
+	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("scout"));
+	assert.equal(assignment("read", { agent: "scout" }), undefined);
+	assert.deepEqual(assignment("subagent_continue", { id: "scout" }), working("Subagent"));
+	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("探索 agent"));
+	assert.deepEqual(assignment("subagent_run", { agent: "🙂".repeat(1000) }), working("🙂".repeat(32)));
 });
 
-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: `scout · ${label}` });
+	for (const kind of ["thinking", "streaming_response"])
+		assert.deepEqual(activity(progress(task("scout", kind))), { activity: "thinking", label: "scout · 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: "first · Exploring... (+2)" });
+	assert.deepEqual(activity(progress(task("first", "tool_running", ["read", "write"]))), { activity: "exploring", label: "first · 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, "scout · 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 and is truncated for display", () => {
+	assert.deepEqual(activity(progress(task("a".repeat(4096)))),
+		{ activity: "exploring", label: `${"a".repeat(32)} · 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: "Agent Name · Executing..." });
+	assert.deepEqual(activity(progress(task("a".repeat(1000), "tool_running", ["b".repeat(1000)]))),
+		{ activity: "executing", label: `${"a".repeat(32)} · 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(agent: string, activity: WorkingActivity): ChildWorkingState {
+	return { activity, label: `${agent} · ${WORKING_ACTIVITY_LABELS[activity]}` };
+}
 
 function record(value: unknown): value is Record<string, unknown> {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -14,22 +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;
-	const label = safeLabel(args.label, 80);
-	return `${agent} · ${label ? `Task: ${label}` : "Task assigned"}`;
+	return childState(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";
+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[] = [];
@@ -38,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;
@@ -58,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(agent, 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", "scout · 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, `scout · ${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", "scout · 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", "writer · 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", "writer · Working...");
+	c.onToolEnd("b"); assertDisplay(working, "exploring", "scout · Exploring...");
 	c.onToolUpdate("subagent_run", "b", childProgress("late"));
-	assert.equal(working.label, "scout · grep");
+	assertDisplay(working, "exploring", "scout · Exploring...");
 	c.onToolUpdate("subagent_run", "a", childProgress("scout", "read", "completed"));
 	assert.equal(working.label, "Delegating...");
 	c.onToolUpdate("subagent_run", "a", childProgress("scout"));
@@ -150,16 +183,20 @@ void test("agent/session disposal clears child progress and rejects late updates
 	}
 });
 
-void test("assignments appear at start and survive unavailable or terminal live progress", (t) => {
+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 · Task: map footer data");
+	assertDisplay(working, "working", "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")]) {
+	assertDisplay(working, "exploring", "explore · 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"));
+		assertDisplay(working, "exploring", "explore · Exploring...");
 		c.onToolUpdate("subagent_run", "a", update);
-		assert.equal(working.label, "explore · Task: map footer data");
+		assertDisplay(working, "working", "explore · Working...");
 	}
 	c.onToolEnd("a"); assert.equal(working.label, "Thinking...");
 });
@@ -168,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 · Task assigned");
+	assert.equal(working.label, "scout · Working...");
 	c.onToolStart("subagent_continue", "b", { id: "a", label: "check footer" });
-	assert.equal(working.label, "Subagent · Task: 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 · Task: check footer");
+	assert.equal(working.label, "Subagent · Working...");
 	c.onToolUpdate("subagent_continue", "b", childProgress("writer", "edit"));
-	assert.equal(working.label, "writer · edit");
+	assertDisplay(working, "working", "writer · Working...");
 	c.onToolUpdate("subagent_run", "a", childProgress("scout"));
-	assert.equal(working.label, "writer · edit");
+	assertDisplay(working, "working", "writer · Working...");
 	c.onToolUpdate("subagent_continue", "b", {});
-	assert.equal(working.label, "Subagent · Task: check footer");
-	c.onToolEnd("b"); assert.equal(working.label, "scout · read");
+	assert.equal(working.label, "Subagent · Working...");
+	c.onToolEnd("b"); assertDisplay(working, "exploring", "scout · Exploring...");
 	c.onToolUpdate("subagent_continue", "b", childProgress("late"));
-	c.onToolUpdate("subagent_run", "a", {}); assert.equal(working.label, "scout · Task assigned");
+	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 · Task: finish");
+	assert.equal(working.label, "writer · Working...");
 	c.onToolEnd("c");
 	c.onToolStart("subagent_continue", "d", { id: "c", task: "SECRET" });
-	assert.equal(working.label, "Subagent · Task assigned");
+	assert.equal(working.label, "Subagent · 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", "public · 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", "Subagent · 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", "first · Exploring... (+1)");
+	c.onToolStart("subagent_run", "continue", { agent: "wrong" });
+	c.onToolUpdate("subagent_run", "continue", childProgress("wrong"));
+	assertDisplay(working, "exploring", "first · Exploring... (+1)");
+	c.onToolUpdate("subagent_continue", "continue", {});
+	assertDisplay(working, "working", "Subagent · 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 · Task: 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);

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.6",
+	"version": "1.11.8",
 	"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": "58395349a28ff9d86413b6fee0d964e477543b3e",
+	"releaseSource": "f0af5964701aaf9022bb79d1ff2d25dbc389b7dc",
 	"repository": {
 		"type": "git",
 		"url": "git+https://github.com/OsdyOrtiz/Osdy-Pi.git"