@selesai/code 0.13.0 → 0.13.1

package/dist/extensions/pi-subagents/test/unit/fleet.test.ts

@@ -309,6 +309,37 @@ describe("native subagent fleet", () => {
 		}
 	});
 
+	it("does not crash Fleet render when live prompt audit stores a non-string authored task", () => {
+		const state = stateForTest();
+		const control = {
+			runId: "bad-prompt-run",
+			sessionId: "session-current",
+			mode: "single" as const,
+			startedAt: 10,
+			updatedAt: 20,
+			activeChildren: new Map([[0, { index: 0, agent: "worker", startedAt: 10, updatedAt: 20 }]]),
+		};
+		state.foregroundControls.set(control.runId, control);
+		registerLivePromptAudit(control, 0, { nested: "task payload" } as unknown as string, "effective prompt");
+		const component = new SubagentFleetComponent(
+			{ terminal: { rows: 28, columns: 100 }, requestRender() {} } as never,
+			theme as never,
+			state,
+			() => {},
+			{ refreshMs: 60_000, markdownTheme },
+		);
+		try {
+			assert.doesNotThrow(() => component.render(100));
+			const rendered = component.render(100).join("\n");
+			assert.doesNotMatch(rendered, /nested|task payload/);
+			component.handleInput("p");
+			assert.doesNotThrow(() => component.render(100));
+			assert.match(component.render(100).join("\n"), /Selected prompt unavailable/);
+		} finally {
+			component.dispose();
+		}
+	});
+
 	it("shows live prompt summaries and opens Prompt Audit with the authored prompt visible", async () => {
 		const sentinel = "PROMPT_AUDIT_SENTINEL_1021";
 		const secondSentinel = "PROMPT_AUDIT_SECOND_CHILD";
@@ -761,7 +792,7 @@ describe("native subagent fleet", () => {
 				cwd,
 				sessionId: "session-current",
 				updatedAt: 200,
-				children: [{ agent: "worker", index: 0, status: "completed", finalOutput: "do not persist this when an artifact exists", savedOutputPath: outputPath, extensionBindings: { "shepherd.dispatch/1": { role: "coder" } } }],
+				children: [{ agent: "worker", index: 0, status: "completed", finalOutput: "do not persist this when an artifact exists", savedOutputPath: outputPath, resumeContract: { outputSchema: { type: "object" }, agentContract: { version: 1 }, acceptance: false, output: false, outputMode: "inline" }, extensionBindings: { "shepherd.dispatch/1": { role: "coder" } } }],
 			});
 			state.foregroundRuns!.set("other-session", {
 				runId: "other-session",
@@ -779,6 +810,7 @@ describe("native subagent fleet", () => {
 			restored.baseCwd = cwd;
 			restored.artifactDirPreference = "project";
 			assert.equal(restoreForegroundRunHistory(restored, { resultsDir }), 1);
+			assert.deepEqual(restored.foregroundRuns?.get("restored")?.children[0]?.resumeContract, { outputSchema: { type: "object" }, agentContract: { version: 1 }, acceptance: false, output: false, outputMode: "inline" });
 			assert.deepEqual(restored.foregroundRuns?.get("restored")?.children[0]?.extensionBindings, { "shepherd.dispatch/1": { role: "coder" } });
 			const snapshot = collectFleetSnapshot(restored);
 			assert.deepEqual(snapshot.items.map((item) => item.key), ["foreground-recent:restored:0"]);
@@ -852,6 +884,45 @@ describe("native subagent fleet", () => {
 		}
 	});
 
+	it("does not restore or persist oversized foreground resume contracts", () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-fleet-foreground-contract-bound-"));
+		try {
+			const resultsDir = path.join(root, "results");
+			fs.mkdirSync(resultsDir, { recursive: true });
+			const oversizedContract = { outputSchema: { type: "object", description: "x".repeat(65 * 1024) } };
+			fs.writeFileSync(path.join(resultsDir, "foreground-history.json"), JSON.stringify({
+				version: 1,
+				runs: [{
+					runId: "oversized",
+					mode: "single",
+					cwd: root,
+					sessionId: "session-current",
+					updatedAt: 200,
+					children: [{ agent: "worker", index: 0, status: "completed", resumeContract: oversizedContract }],
+				}],
+			}), "utf-8");
+
+			const restored = stateForTest();
+			assert.equal(restoreForegroundRunHistory(restored, { resultsDir }), 0);
+			assert.equal(restored.foregroundRuns?.has("oversized"), false);
+
+			const state = stateForTest();
+			state.foregroundRuns!.set("oversized", {
+				runId: "oversized",
+				mode: "single",
+				cwd: root,
+				sessionId: "session-current",
+				updatedAt: 200,
+				children: [{ agent: "worker", index: 0, status: "completed", resumeContract: oversizedContract }],
+			});
+			persistForegroundRunHistory(state, { resultsDir });
+			const persisted = JSON.parse(fs.readFileSync(path.join(resultsDir, "foreground-history.json"), "utf-8")) as { runs: Array<{ runId: string }> };
+			assert.deepEqual(persisted.runs, []);
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
 	it("keeps restored foreground rows when output artifacts are unavailable and bounds history", () => {
 		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-fleet-foreground-missing-"));
 		try {
@@ -978,6 +1049,44 @@ describe("native subagent fleet", () => {
 		}
 	});
 
+	it("previews an exact runtime-recorded workflow session under the Pi sessions base", () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-fleet-recorded-session-"));
+		try {
+			const asyncDir = writeAsyncRun(root, { id: "async-recorded-session" });
+			const sessionsBase = path.join(root, "sessions");
+			const projectDir = path.join(sessionsBase, "project");
+			fs.mkdirSync(projectDir, { recursive: true });
+			const sessionFile = path.join(projectDir, "workflow-child.jsonl");
+			fs.writeFileSync(sessionFile, `${JSON.stringify({ role: "assistant", content: "RECORDED WORKFLOW SESSION" })}\n`, "utf-8");
+			const statusPath = path.join(asyncDir, "status.json");
+			const status = JSON.parse(fs.readFileSync(statusPath, "utf-8")) as { sessionFile?: string; steps?: Array<{ sessionFile?: string; transcriptPath?: string }> };
+			status.sessionFile = sessionFile;
+			status.steps![0]!.sessionFile = sessionFile;
+			delete status.steps![0]!.transcriptPath;
+			fs.writeFileSync(statusPath, JSON.stringify(status, null, 2), "utf-8");
+
+			const state = stateForTest();
+			state.trustedSessionRoots = [];
+			state.trustedSessionFileRoot = sessionsBase;
+			const component = new SubagentFleetComponent(
+				{ terminal: { rows: 32, columns: 100 }, requestRender() {} } as never,
+				theme as never,
+				state,
+				() => {},
+				{ asyncDirRoot: root, resultsDir: path.join(root, "results"), refreshMs: 60_000 },
+			);
+			try {
+				const rendered = component.render(100).join("\n");
+				assert.match(rendered, /RECORDED WORKFLOW SESSION/);
+				assert.doesNotMatch(rendered, /without a trusted root|Session read failed/);
+			} finally {
+				component.dispose();
+			}
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
 	it("renders structured tool activity and assistant Markdown when a child transcript is available", () => {
 		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-fleet-structured-"));
 		try {

package/dist/extensions/pi-subagents/test/unit/foreground-control.test.ts

@@ -15,6 +15,7 @@ function progress(index: number, agent: string, tokens: number): AgentProgress {
 	return {
 		index,
 		agent,
+		sessionName: `  ${agent}: named task  `,
 		status: "running",
 		task: `${agent} task`,
 		recentTools: [],
@@ -25,6 +26,8 @@ function progress(index: number, agent: string, tokens: number): AgentProgress {
 		thinking: "high",
 		inputTokens: tokens - 20,
 		outputTokens: 20,
+		window: 75,
+		windowPeak: 90,
 		durationMs: 10,
 	};
 }
@@ -67,9 +70,13 @@ describe("foreground child control", () => {
 		assert.equal(control.currentIndex, 1);
 		updateForegroundChild(control, 0, progress(0, "reviewer", 120));
 		assert.equal(control.currentIndex, 0);
+		assert.equal(control.sessionName, "  reviewer: named task  ");
+		assert.equal(control.activeChildren?.get(0)?.sessionName, "  reviewer: named task  ");
 		assert.equal(control.tokens, 120);
 		assert.equal(control.inputTokens, 100);
 		assert.equal(control.outputTokens, 20);
+		assert.equal(control.window, 75);
+		assert.equal(control.windowPeak, 90);
 		assert.equal(control.model, "openai/gpt-5.6-terra:high");
 		assert.equal(control.thinking, "high");
 		assert.equal(control.activeChildren?.get(1)?.tokens, undefined);
@@ -89,9 +96,12 @@ describe("foreground child control", () => {
 		finishForegroundChild(control, 0);
 		assert.equal(control.activeChildren?.size, 0);
 		assert.equal(control.currentIndex, undefined);
+		assert.equal(control.sessionName, undefined);
 		assert.equal(control.model, undefined);
 		assert.equal(control.inputTokens, undefined);
 		assert.equal(control.outputTokens, undefined);
+		assert.equal(control.window, undefined);
+		assert.equal(control.windowPeak, undefined);
 		assert.equal(control.interrupt, undefined);
 		assert.equal(control.detach, undefined);
 	});

package/dist/extensions/pi-subagents/test/unit/formatters.test.ts

@@ -0,0 +1,14 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { formatContextUsage, formatTokens } from "../../src/shared/formatters.ts";
+
+test("formats million-scale token values with an M suffix", () => {
+	assert.equal(formatTokens(999_499), "999k");
+	assert.equal(formatTokens(999_500), "1M");
+	assert.equal(formatTokens(1_000_000), "1M");
+	assert.equal(formatTokens(1_250_000), "1.3M");
+});
+
+test("formats million-scale context limits clearly", () => {
+	assert.equal(formatContextUsage({ window: 93_000 }, 1_000_000), "ctx 93k/1M (9%)");
+});

package/dist/extensions/pi-subagents/test/unit/herdr-inspector.test.ts

@@ -9,10 +9,20 @@ import { handleHerdrInspectorAction, readHerdrInspectorBinding } from "../../src
 import { createHerdrClient, detectHerdr, parseHerdrVersion, supportsRawPanes, type HerdrClient } from "../../src/inspectors/herdr/client.ts";
 import { formatInspectorDashboard, submitInspectorControl } from "../../src/inspectors/herdr/inspector-runner.ts";
 import { createProjectPaneManager, handleHerdrProjectPaneAction, listHerdrProjectPaneRoots, readHerdrProjectPaneBinding, restoreHerdrProjectPaneSnapshots } from "../../src/inspectors/herdr/project-panes.ts";
+import { decodeSessionRoots } from "../../src/inspectors/herdr/session-roots-codec.ts";
 import { consumeSteerRequests, consumeStopRequest } from "../../src/runs/background/control-channel.ts";
-import { SELESAI_SUBAGENT_PI_BINARY_ENV } from "../../src/runs/shared/pi-spawn.ts";
+import { SELESAI_SUBAGENT_SELESAI_BINARY_ENV } from "../../src/runs/shared/pi-spawn.ts";
 import type { AsyncStatus, SubagentState } from "../../src/shared/types.ts";
 
+// `pane run` commands quote the whole --session-roots value (base64, so it has
+// no spaces/quotes of its own); pull it back out and decode it the same way
+// the inspector runner does, rather than pattern-matching on the raw text.
+function sessionRootsFromRunCommand(command: string): string[] {
+	const match = /--session-roots\S*\s+['"]?([A-Za-z0-9+/=]+)/.exec(command);
+	assert.ok(match, `--session-roots argument not found in command: ${command}`);
+	return decodeSessionRoots(match[1]);
+}
+
 function fakeChild(): EventEmitter & { stdout: PassThrough; stderr: PassThrough; kill(): boolean } {
 	const child = new EventEmitter() as EventEmitter & { stdout: PassThrough; stderr: PassThrough; kill(): boolean };
 	child.stdout = new PassThrough();
@@ -120,7 +130,7 @@ describe("Herdr inspector", () => {
 				assert.ok(!/^[']/.test(runCall[3] ?? ""), `pane run command must not open with a quoted executable; Nushell parses it as a string expression: ${runCall[3]}`);
 			}
 			assert.match(runCall[3] ?? "", /--allow-steer.*true.*--allow-stop.*true/);
-			assert.match(runCall[3] ?? "", /--session-roots.*sessions/);
+			assert.deepEqual(sessionRootsFromRunCommand(runCall[3] ?? ""), [sessionRoot]);
 
 			const closed = await handleHerdrInspectorAction("inspector.close", { dir: asyncDir }, { cwd: root, asyncDirRoot: root, client });
 			assert.equal(closed.isError, undefined, text(closed));
@@ -180,8 +190,7 @@ describe("Herdr inspector", () => {
 			});
 			assert.equal(opened.isError, undefined, text(opened));
 			const runCall = calls.find((args) => args[0] === "pane" && args[1] === "run" && args[2] === "w1:p11");
-			assert.match(runCall?.[3] ?? "", /--session-roots/);
-			assert.match(runCall?.[3] ?? "", /custom-sessions/);
+			assert.deepEqual(sessionRootsFromRunCommand(runCall?.[3] ?? ""), [sessionRoot]);
 
 			state.asyncJobs.clear();
 			fs.rmSync(path.join(asyncDir, "inspectors"), { recursive: true, force: true });
@@ -195,7 +204,7 @@ describe("Herdr inspector", () => {
 			});
 			assert.equal(reopened.isError, undefined, text(reopened));
 			const untrustedRunCall = calls.find((args) => args[0] === "pane" && args[1] === "run" && args[2] === "w1:p11");
-			assert.doesNotMatch(untrustedRunCall?.[3] ?? "", /custom-sessions/);
+			assert.deepEqual(sessionRootsFromRunCommand(untrustedRunCall?.[3] ?? ""), []);
 		} finally {
 			fs.rmSync(root, { recursive: true, force: true });
 		}
@@ -280,8 +289,8 @@ describe("Herdr inspector", () => {
 
 	it("opens, reports, and closes a project-owned Herdr pane", async () => {
 		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi=herdr project pane-"));
-		const previousPiBinary = process.env[SELESAI_SUBAGENT_PI_BINARY_ENV];
-		process.env[SELESAI_SUBAGENT_PI_BINARY_ENV] = path.join(root, "pi-bin");
+		const previousPiBinary = process.env[SELESAI_SUBAGENT_SELESAI_BINARY_ENV];
+		process.env[SELESAI_SUBAGENT_SELESAI_BINARY_ENV] = path.join(root, "pi-bin");
 		try {
 			const projectRoot = fs.realpathSync(root);
 			const ownerRoot = path.join(root, "owner");
@@ -352,8 +361,8 @@ describe("Herdr inspector", () => {
 			fs.writeFileSync(path.join(ownerRoot, ".pi-subagents/project-panes/herdr-roots.json"), JSON.stringify({ schemaVersion: 1, kind: "herdr-project-pane-roots", projectRoots: [123] }));
 			assert.throws(() => listHerdrProjectPaneRoots(ownerRoot), /Invalid Herdr project pane root index/);
 		} finally {
-			if (previousPiBinary === undefined) delete process.env[SELESAI_SUBAGENT_PI_BINARY_ENV];
-			else process.env[SELESAI_SUBAGENT_PI_BINARY_ENV] = previousPiBinary;
+			if (previousPiBinary === undefined) delete process.env[SELESAI_SUBAGENT_SELESAI_BINARY_ENV];
+			else process.env[SELESAI_SUBAGENT_SELESAI_BINARY_ENV] = previousPiBinary;
 			fs.rmSync(root, { recursive: true, force: true });
 		}
 	});

package/dist/extensions/pi-subagents/test/unit/herdr-session-roots-codec.test.ts

@@ -0,0 +1,63 @@
+import assert from "node:assert/strict";
+import { execFileSync } from "node:child_process";
+import { describe, it } from "node:test";
+import { decodeSessionRoots, encodeSessionRoots } from "../../src/inspectors/herdr/session-roots-codec.ts";
+import { formatShellCommand } from "../../src/inspectors/herdr/shell-command.ts";
+
+describe("session roots codec", () => {
+	it("round-trips an empty array, plain paths, and paths with spaces/quotes", () => {
+		for (const roots of [[], ["/tmp/a"], ["C:\\Users\\a b\\.selesai", "D:\\work"], ['has "quotes"', "has\\backslashes\\"]]) {
+			assert.deepEqual(decodeSessionRoots(encodeSessionRoots(roots)), roots);
+		}
+	});
+
+	it("still accepts raw JSON for backward compatibility with unpatched callers", () => {
+		assert.deepEqual(decodeSessionRoots(JSON.stringify(["/tmp/a", "/tmp/b"])), ["/tmp/a", "/tmp/b"]);
+		assert.deepEqual(decodeSessionRoots(JSON.stringify([])), []);
+	});
+
+	it("rejects malformed input from either encoding", () => {
+		assert.throws(() => decodeSessionRoots("not base64 and not json"), /base64-encoded or raw JSON array of strings/);
+		assert.throws(() => decodeSessionRoots(Buffer.from(JSON.stringify({ not: "an array" })).toString("base64")), /base64-encoded or raw JSON array of strings/);
+		assert.throws(() => decodeSessionRoots(Buffer.from(JSON.stringify([1, 2])).toString("base64")), /base64-encoded or raw JSON array of strings/);
+	});
+
+	it("produces plain-ASCII base64 output with no quote, backslash, or space characters for a shell to mangle", () => {
+		const encoded = encodeSessionRoots(["C:\\Users\\a b\\.selesai\\sessions", 'contains "quotes"', "D:\\work"]);
+		assert.match(encoded, /^[A-Za-z0-9+/=]+$/);
+	});
+
+	// This is the actual regression: Windows PowerShell has no backslash-escape for
+	// embedded double quotes (only `` `" `` or `""`), so shellQuote's win32 branch
+	// (which escapes `"` as `\"`) corrupts any argument containing a literal `"` -
+	// exactly what `JSON.stringify(sessionRoots)` produces. Spawn real powershell.exe
+	// to prove the old approach breaks and the new approach survives.
+	describe("end-to-end through real powershell.exe", { skip: process.platform !== "win32" }, () => {
+		function echoArgvCommand(sessionRootsArg: string): string {
+			const script = "process.stdout.write(JSON.stringify(process.argv.slice(1)));";
+			return formatShellCommand(process.execPath, ["-e", script, "--", "--session-roots", sessionRootsArg], "win32");
+		}
+
+		function runThroughPowerShell(command: string): string[] {
+			return JSON.parse(execFileSync("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", command], { encoding: "utf-8" }));
+		}
+
+		it("mangles a raw JSON.stringify payload (documents the bug this PR fixes)", () => {
+			const sessionRoots = ["C:\\Users\\sgerashe\\.selesai\\sessions", "D:\\work\\proj"];
+			const rawJson = JSON.stringify(sessionRoots);
+			const argv = runThroughPowerShell(echoArgvCommand(rawJson));
+			const received = argv[argv.indexOf("--session-roots") + 1];
+			assert.notEqual(received, rawJson, "expected PowerShell to corrupt the unescaped JSON payload");
+			assert.throws(() => JSON.parse(received ?? ""), /Unexpected token/, "corrupted payload should no longer be valid JSON");
+		});
+
+		it("survives base64 encoding byte-for-byte", () => {
+			const sessionRoots = ["C:\\Users\\sgerashe\\.selesai\\sessions", "D:\\work\\proj", 'C:\\has "quotes"\\dir'];
+			const encoded = encodeSessionRoots(sessionRoots);
+			const argv = runThroughPowerShell(echoArgvCommand(encoded));
+			const received = argv[argv.indexOf("--session-roots") + 1];
+			assert.equal(received, encoded);
+			assert.deepEqual(decodeSessionRoots(received ?? ""), sessionRoots);
+		});
+	});
+});

package/dist/extensions/pi-subagents/test/unit/herdr-shell-command.test.ts

@@ -11,8 +11,8 @@ describe("formatShellCommand on POSIX shells", () => {
 
 	it("keeps a shell-safe executable bare so Nushell parses it as a command", () => {
 		assert.equal(
-			formatShellCommand("/usr/bin/node", ["/home/u/.pi/inspector-runner.mjs", "--async-dir", "/tmp/run-1|fc_abc"], platform),
-			"/usr/bin/node '/home/u/.pi/inspector-runner.mjs' '--async-dir' '/tmp/run-1|fc_abc'",
+			formatShellCommand("/usr/bin/node", ["/home/u/.selesai/inspector-runner.mjs", "--async-dir", "/tmp/run-1|fc_abc"], platform),
+			"/usr/bin/node '/home/u/.selesai/inspector-runner.mjs' '--async-dir' '/tmp/run-1|fc_abc'",
 		);
 	});
 

package/dist/extensions/pi-subagents/test/unit/herdr-status-bridge.test.ts

@@ -4,6 +4,7 @@ import { describe, it } from "node:test";
 import {
 	registerHerdrStatusBridge,
 	type HerdrStatusBridgeEvents,
+	type HerdrStatusRun,
 } from "../../src/integrations/herdr-status.ts";
 import { projectActiveHerdrRuns } from "../../src/extension/index.ts";
 import type { SubagentState } from "../../src/shared/types.ts";
@@ -82,6 +83,7 @@ describe("Herdr status bridge", () => {
 			status: "running",
 			mode: "workflow",
 			agents: ["workflow"],
+			steps: [{ agent: "reviewer", status: "running", label: "Review auth" }],
 		});
 		state.foregroundControls.set("child-1", {
 			runId: "child-1",
@@ -102,10 +104,32 @@ describe("Herdr status bridge", () => {
 		assert.deepEqual(projectActiveHerdrRuns(state), [{
 			id: "workflow-1",
 			agents: ["reviewer"],
+			taskLabel: "Review auth",
 			needsAttention: true,
 		}]);
 	});
 
+	it("synchronizes runs discovered outside lifecycle events", async () => {
+		const events = new FakeEvents();
+		const commands: string[][] = [];
+		const bridge = registerHerdrStatusBridge({
+			events,
+			env: { HERDR_ENV: "1", HERDR_PANE_ID: "w1:p1" },
+			getRuns: () => [{ id: "restored-run", agent: "worker" }],
+			runHerdr: (args) => commands.push([...args]),
+			refreshMs: 0,
+		});
+		bridge.sessionStarted({ hasUI: true, runs: [] });
+
+		bridge.syncRuns();
+		await bridge.flush();
+
+		assert.equal(commands.length, 1);
+		assert.ok(commands[0]?.includes("summary=⏳ 1 subagent (worker)"));
+
+		bridge.dispose();
+	});
+
 	it("reports an async run as visible and semantically busy", async () => {
 		const events = new FakeEvents();
 		const commands: string[][] = [];
@@ -428,6 +452,100 @@ describe("Herdr status bridge", () => {
 		bridge.dispose();
 	});
 
+	it("publishes bounded workflow labels without leaking raw prompts and restores the previous overlapping task", async () => {
+		const events = new FakeEvents();
+		const commands: string[][] = [];
+		const bridge = registerHerdrStatusBridge({
+			events,
+			env: { HERDR_ENV: "1", HERDR_PANE_ID: "w1:p1" },
+			runHerdr: (args) => commands.push([...args]),
+			refreshMs: 0,
+		});
+		bridge.sessionStarted({ hasUI: true, runs: [] });
+
+		events.emit(SUBAGENT_ASYNC_STARTED_EVENT, {
+			id: "run-1",
+			agent: "worker",
+			goal: "raw secret prompt",
+			workflowGraph: {
+				currentNodeId: "build",
+				nodes: [{ id: "build", status: "running", label: "Build auth\nflow\u001b[31m" }],
+			},
+		});
+		await bridge.flush();
+		events.emit(SUBAGENT_ASYNC_STARTED_EVENT, {
+			id: "run-2",
+			agent: "reviewer",
+			task: "another raw prompt",
+			workflowGraph: {
+				nodes: [{ id: "review", status: "pending", label: `Review ${"x".repeat(120)}` }],
+			},
+		});
+		await bridge.flush();
+		events.emit(SUBAGENT_ASYNC_COMPLETE_EVENT, { runId: "run-2" });
+		await bridge.flush();
+		events.emit(SUBAGENT_ASYNC_COMPLETE_EVENT, { runId: "run-1" });
+		await bridge.flush();
+
+		assert.ok(commands[0]?.includes("summary=⏳ 1 subagent (worker) · Build auth flow"));
+		assert.ok(commands[0]?.includes("title-suffix=⏳Build auth flow"));
+		assert.ok(commands[1]?.some((argument) => argument.startsWith("summary=⏳ 2 subagents") && argument.length < 180));
+		assert.ok(commands[1]?.some((argument) => argument.startsWith("title-suffix=⏳Review ") && argument.length < 70));
+		assert.ok(commands[2]?.includes("title-suffix=⏳Build auth flow"));
+		assert.ok(commands[3]?.includes("--clear-state-labels"));
+		assert.doesNotMatch(commands.flat().join("\n"), /raw secret prompt|another raw prompt/);
+
+		bridge.dispose();
+	});
+
+	it("omits refreshed task labels when sanitization removes all content", async () => {
+		const events = new FakeEvents();
+		const commands: string[][] = [];
+		const bridge = registerHerdrStatusBridge({
+			events,
+			env: { HERDR_ENV: "1", HERDR_PANE_ID: "w1:p1" },
+			runHerdr: (args) => commands.push([...args]),
+			refreshMs: 0,
+		});
+
+		bridge.sessionStarted({ hasUI: true, runs: [{ id: "run-1", agent: "worker", taskLabel: "\u001b[31m" }] });
+		await bridge.flush();
+
+		assert.ok(commands[0]?.includes("summary=⏳ 1 subagent (worker)"));
+		assert.ok(commands[0]?.includes("title-suffix=⏳worker"));
+		assert.doesNotMatch(commands.flat().join("\n"), /\u001b\[31m/);
+
+		bridge.dispose();
+	});
+
+	it("clears a completed step label when the authoritative active step is unlabeled", async () => {
+		const events = new FakeEvents();
+		const commands: string[][] = [];
+		const intervals = new FakeIntervals();
+		let authoritativeRuns: HerdrStatusRun[] = [{ id: "run-1", agent: "worker", taskLabel: "Build auth" }];
+		const bridge = registerHerdrStatusBridge({
+			events,
+			env: { HERDR_ENV: "1", HERDR_PANE_ID: "w1:p1" },
+			getRuns: () => authoritativeRuns,
+			runHerdr: (args) => commands.push([...args]),
+			refreshMs: 45_000,
+			timers: intervals.timers,
+		});
+		bridge.sessionStarted({ hasUI: true, runs: authoritativeRuns });
+		await bridge.flush();
+
+		authoritativeRuns = [{ id: "run-1", agent: "worker" }];
+		intervals.fireAll();
+		await bridge.flush();
+
+		assert.ok(commands[0]?.includes("title-suffix=⏳Build auth"));
+		assert.ok(commands[1]?.includes("summary=⏳ 1 subagent (worker)"));
+		assert.ok(commands[1]?.includes("title-suffix=⏳worker"));
+		assert.doesNotMatch(commands[1]?.join("\n") ?? "", /Build auth/);
+
+		bridge.dispose();
+	});
+
 	it("refreshes metadata only while runs are active", async () => {
 		const events = new FakeEvents();
 		const commands: string[][] = [];
@@ -533,10 +651,15 @@ describe("Herdr status bridge", () => {
 		const events = new FakeEvents();
 		const commands: string[][] = [];
 		const busyEvents: unknown[] = [];
+		let getRunsCalls = 0;
 		events.on("herdr:busy", (payload) => busyEvents.push(payload));
 		const bridge = registerHerdrStatusBridge({
 			events,
 			env: { HERDR_ENV: "1", HERDR_PANE_ID: "w1:p1" },
+			getRuns: () => {
+				getRunsCalls += 1;
+				return [{ id: "run-authoritative", agent: "worker" }];
+			},
 			runHerdr: (args) => commands.push([...args]),
 			refreshMs: 0,
 		});
@@ -549,10 +672,12 @@ describe("Herdr status bridge", () => {
 
 		// A headless parent (print/json mode, or a test harness) must never publish.
 		bridge.sessionStarted({ hasUI: false, runs: [{ id: "run-headless", agent: "worker" }] });
+		bridge.syncRuns();
 		events.emit(SUBAGENT_ASYNC_STARTED_EVENT, { id: "run-1", agent: "worker" });
 		await bridge.flush();
 		assert.deepEqual(commands, []);
 		assert.deepEqual(busyEvents, []);
+		assert.equal(getRunsCalls, 0);
 
 		// Only the root interactive session owns the pane.
 		bridge.sessionStarted({ hasUI: true, runs: [] });
@@ -568,19 +693,26 @@ describe("Herdr status bridge", () => {
 	it("stays inert outside a Herdr pane", async () => {
 		const events = new FakeEvents();
 		const commands: string[][] = [];
+		let getRunsCalls = 0;
 		const bridge = registerHerdrStatusBridge({
 			events,
 			env: {},
+			getRuns: () => {
+				getRunsCalls += 1;
+				return [{ id: "run-2", agent: "reviewer" }];
+			},
 			runHerdr: (args) => commands.push([...args]),
 			refreshMs: 0,
 		});
 
 		bridge.sessionStarted({ hasUI: true, runs: [{ id: "run-2", agent: "reviewer" }] });
+		bridge.syncRuns();
 		events.emit(SUBAGENT_ASYNC_STARTED_EVENT, { id: "run-1", agent: "worker" });
 		bridge.agentStarted();
 		bridge.dispose();
 		await bridge.flush();
 
 		assert.deepEqual(commands, []);
+		assert.equal(getRunsCalls, 0);
 	});
 });