@selesai/code 0.13.12 → 0.13.14

package/dist/extensions/pi-subagents/test/unit/workflow-checklist.test.ts

@@ -0,0 +1,223 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { formatWorkflowChecklistBottleneck, formatWorkflowChecklistText, projectWorkflowChecklist } from "../../src/workflows/workflow-checklist.ts";
+import type { HostStepNodeV1, WorkflowGraphSnapshot } from "../../src/shared/types.ts";
+
+function graph(): WorkflowGraphSnapshot {
+	return {
+		runId: "workflow-checklist",
+		mode: "workflow",
+		phases: [
+			{ title: "inventory", nodeIds: ["inventory"] },
+			{ title: "writers", nodeIds: ["writer-a", "writer-b"] },
+			{ title: "reviews", nodeIds: ["review"] },
+			{ title: "gate", nodeIds: ["gate"] },
+		],
+		nodes: [
+			{ id: "inventory", kind: "step", label: "inventory", agent: "scout", status: "completed", flatIndex: 0 },
+			{ id: "writer-a", kind: "agent", label: "writer-a", agent: "writer", status: "completed", flatIndex: 1 },
+			{ id: "writer-b", kind: "agent", label: "writer-b", agent: "writer", status: "running", flatIndex: 2 },
+			{ id: "review", kind: "step", label: "review", agent: "reviewer", status: "pending", flatIndex: 3 },
+			{ id: "gate", kind: "step", label: "gate", agent: "reviewer", status: "pending", acceptanceStatus: "rejected", flatIndex: 4 },
+		],
+	};
+}
+
+test("workflow checklist fuses graph phases with loaded child state without duplicate rows", () => {
+	const projection = projectWorkflowChecklist({
+		graph: graph(),
+		steps: [
+			{ workflowKey: "inventory", agent: "scout", status: "complete" },
+			{ workflowKey: "writer-a", agent: "writer", status: "complete" },
+			{ workflowKey: "writer-b", agent: "writer", status: "running", currentTool: "grep", toolCount: 18, startedAt: 1000 },
+			{ workflowKey: "review", agent: "reviewer", status: "pending", context: "fork" },
+		],
+		now: 5000,
+	});
+
+	assert.deepEqual(projection.phases.map((phase) => [phase.label, phase.state, phase.total, phase.done]), [
+		["inventory", "complete", 1, 1],
+		["writers", "running", 2, 1],
+		["reviews", "queued", 1, 0],
+		["gate", "blocked", 1, 0],
+	]);
+	assert.deepEqual([projection.total, projection.done, projection.running, projection.queued, projection.blocked], [5, 2, 1, 1, 1]);
+	assert.equal(projection.phases.flatMap((phase) => phase.items).length, 5);
+	assert.equal(projection.phases[1]!.items[1]!.durationMs, 4000);
+	assert.equal(projection.phases[2]!.items[0]!.context, "fork");
+	assert.equal(projection.bottleneck?.key, "gate");
+});
+
+test("workflow checklist preserves explicit host monitor verdicts and trace lane identity", () => {
+	const host: HostStepNodeV1 = {
+		version: 1,
+		kind: "host-step",
+		monitorKind: "ci",
+		id: "ci",
+		label: "CI",
+		provider: "buildkite",
+		state: "done",
+		verdict: "inconclusive",
+		target: "main",
+		freshness: { expectedRef: "main", stale: true },
+		updatedAt: 1000,
+	};
+	const projection = projectWorkflowChecklist({
+		hostSteps: [host],
+		preflight: { version: 1, coverage: "partial", lanes: [{ key: "reviewers", mode: "review" }] },
+		trace: [
+			{ operation: "run", key: "reviewers.a", generatedLaneKey: "reviewers", state: "started", agent: "reviewer" },
+			{ operation: "run", key: "reviewers.a", generatedLaneKey: "reviewers", state: "completed", agent: "reviewer" },
+		],
+	});
+
+	assert.deepEqual(projection.phases.map((phase) => phase.label), ["CI", "reviewers"]);
+	assert.equal(projection.phases[0]!.items[0]!.state, "blocked");
+	assert.equal(projection.phases[0]!.items[0]!.monitorKind, "ci");
+	assert.equal(projection.phases[0]!.items[0]!.verdict, "inconclusive");
+	assert.equal(projection.phases[1]!.items[0]!.state, "complete");
+	assert.equal(projection.phases[1]!.items[0]!.preflight?.mode, "review");
+	assert.match(formatWorkflowChecklistBottleneck(projection.bottleneck) ?? "", /CI/);
+});
+
+test("workflow checklist counts one host monitor when host status and trace share an id", () => {
+	const host: HostStepNodeV1 = {
+		version: 1,
+		kind: "host-step",
+		monitorKind: "ci",
+		id: "ci",
+		label: "CI",
+		state: "done",
+		verdict: "pass",
+		updatedAt: 1000,
+	};
+	const projection = projectWorkflowChecklist({
+		hostSteps: [host],
+		trace: [{ operation: "host", key: "ci", state: "completed", label: "CI" }],
+	});
+
+	assert.equal(projection.total, 1);
+	assert.deepEqual(projection.phases.flatMap((phase) => phase.items).map((item) => [item.key, item.kind, item.state]), [["ci", "host", "complete"]]);
+});
+
+test("workflow checklist keeps terminal child state newer than stale running trace", () => {
+	const projection = projectWorkflowChecklist({
+		graph: graph(),
+		steps: [{ workflowKey: "writer-b", agent: "writer", status: "complete" }],
+		trace: [{ operation: "run", key: "writer-b", state: "started", agent: "writer" }],
+	});
+
+	assert.equal(projection.running, 0);
+	assert.equal(projection.phases[1]!.items[1]!.state, "complete");
+});
+
+test("workflow checklist keeps terminal graph state newer than stale running child state", () => {
+	const snapshot = graph();
+	snapshot.nodes[2] = { ...snapshot.nodes[2]!, status: "failed", error: "writer failed" };
+	const projection = projectWorkflowChecklist({
+		graph: snapshot,
+		steps: [{ workflowKey: "writer-b", agent: "writer", status: "running" }],
+		trace: [{ operation: "run", key: "writer-b", state: "started", agent: "writer" }],
+	});
+
+	assert.equal(projection.running, 0);
+	assert.equal(projection.failed, 1);
+	assert.equal(projection.phases[1]!.state, "failed");
+	assert.equal(projection.phases[1]!.items[1]!.state, "failed");
+});
+
+test("workflow checklist keeps terminal graph state newer than stale trace without loaded child state", () => {
+	const snapshot = graph();
+	snapshot.nodes[2] = { ...snapshot.nodes[2]!, status: "failed", error: "writer failed" };
+	const projection = projectWorkflowChecklist({
+		graph: snapshot,
+		trace: [{ operation: "run", key: "writer-b", state: "started", agent: "writer" }],
+	});
+
+	assert.equal(projection.running, 0);
+	assert.equal(projection.failed, 1);
+	assert.equal(projection.phases[1]!.items[1]!.state, "failed");
+});
+
+test("workflow checklist keeps graph acceptance blockers ahead of stale running child state", () => {
+	const snapshot = graph();
+	snapshot.nodes[2] = { ...snapshot.nodes[2]!, acceptanceStatus: "rejected" };
+	const projection = projectWorkflowChecklist({
+		graph: snapshot,
+		steps: [{ workflowKey: "writer-b", agent: "writer", status: "running" }],
+		trace: [{ operation: "run", key: "writer-b", state: "started", agent: "writer" }],
+	});
+
+	assert.equal(projection.running, 0);
+	assert.equal(projection.blocked, 2);
+	assert.equal(projection.phases[1]!.items[1]!.state, "blocked");
+});
+
+test("workflow checklist uses preflight only to annotate authoritative work", () => {
+	const projection = projectWorkflowChecklist({
+		graph: graph(),
+		preflight: { version: 1, coverage: "partial", lanes: [{ key: "writer-b", mode: "mutation" }, { key: "writers", mode: "mutation" }, { key: "deploy", mode: "gate" }] },
+	});
+
+	assert.equal(projection.total, 5);
+	assert.deepEqual(projection.phases.map((phase) => phase.label), ["inventory", "writers", "reviews", "gate"]);
+	assert.equal(projection.queued, 1);
+	assert.equal(projection.phases[2]?.items[0]?.key, "review");
+});
+
+test("workflow checklist does not turn unmatched preflight metadata into queued work", () => {
+	const preflight = { version: 1 as const, coverage: "partial" as const, lanes: [{ key: "pr14", mode: "review" as const }] };
+	const declarationOnly = projectWorkflowChecklist({ preflight });
+	const mismatchedRuntime = projectWorkflowChecklist({
+		preflight,
+		trace: [{ operation: "run", key: "pr14-quality", state: "started", agent: "reviewer" }],
+	});
+
+	assert.deepEqual(declarationOnly, { phases: [], total: 0, done: 0, running: 0, queued: 0, blocked: 0, failed: 0, paused: 0, stopped: 0 });
+	assert.equal(mismatchedRuntime.total, 1);
+	assert.equal(mismatchedRuntime.running, 1);
+	assert.equal(mismatchedRuntime.queued, 0);
+	assert.deepEqual(mismatchedRuntime.phases.flatMap((phase) => phase.items).map((item) => item.key), ["pr14-quality"]);
+});
+
+test("workflow checklist prefers specific dotted preflight lanes over generated aliases", () => {
+	const projection = projectWorkflowChecklist({
+		preflight: {
+			version: 1,
+			coverage: "partial",
+			lanes: [
+				{ key: "writer", mode: "mutation" },
+				{ key: "writer.quality", mode: "review" },
+			],
+		},
+		trace: [{ operation: "run", key: "writer.quality.deep", generatedLaneKey: "writer", state: "started", agent: "reviewer" }],
+	});
+
+	assert.equal(projection.total, 1);
+	assert.deepEqual(projection.phases.map((phase) => phase.label), ["writer.quality"]);
+	assert.equal(projection.phases[0]?.items[0]?.preflight?.mode, "review");
+});
+
+test("workflow checklist text exposes aggregate, phase, and bottleneck signals with bounded errors", () => {
+	const projection = projectWorkflowChecklist({
+		trace: [{ operation: "run", key: "review", state: "failed", label: "reviewer", agent: "reviewer", error: "Output: secret details" }],
+	});
+	const text = formatWorkflowChecklistText(projection).join("\n");
+	assert.match(text, /Workflow checklist: 0\/1 done · 1 failed/);
+	assert.match(text, /reviewer/);
+	assert.match(text, /bottleneck/);
+	assert.doesNotMatch(text, /Output:/);
+});
+
+test("workflow checklist text can suppress item rows for status surfaces", () => {
+	const projection = projectWorkflowChecklist({
+		graph: graph(),
+		steps: [{ workflowKey: "writer-b", agent: "writer", status: "running" }],
+	});
+	const text = formatWorkflowChecklistText(projection, "", { includeItems: false }).join("\n");
+
+	assert.match(text, /Workflow checklist:/);
+	assert.match(text, /writers 1 done · 1 active/);
+	assert.doesNotMatch(text, /writer-b · writer · active/);
+});

package/dist/extensions/pi-subagents/test/unit/workflow-launch-params.test.ts

@@ -1,6 +1,7 @@
 import assert from "node:assert/strict";
 import { describe, it } from "node:test";
-import { prepareWorkflowLaunchParams, promptAuditRedoParams, sanitizeRunPathSegment } from "../../src/runs/foreground/subagent-executor.ts";
+import { prepareWorkflowLaunchParams, promptAuditRedoParams, resolveRevivalControlConfig, sanitizeRunPathSegment } from "../../src/runs/foreground/subagent-executor.ts";
+import { resolveControlConfig } from "../../src/runs/shared/subagent-control.ts";
 
 describe("workflow launch params", () => {
 	it("keeps omitted workflow child async foreground", () => {
@@ -32,6 +33,20 @@ describe("workflow launch params", () => {
 		assert.equal(params.maxSubagentSpawnsPerRun, undefined);
 	});
 
+	it("merges partial control overrides into workflow child defaults", () => {
+		const params = prepareWorkflowLaunchParams(
+			{ control: { needsAttentionAfterMs: 111, activeNoticeAfterMs: 222 } },
+			{ agent: "worker", task: "Run", control: { activeNoticeAfterMs: 333 } },
+			"workflow-run",
+			"run",
+		);
+
+		assert.deepEqual(params.control, {
+			needsAttentionAfterMs: 111,
+			activeNoticeAfterMs: 333,
+		});
+	});
+
 	it("marks only new async workflow children to preserve live supervisor-detach awaits", () => {
 		// Retained workflow children already use the async result-file await path.
 		assert.equal(prepareWorkflowLaunchParams(
@@ -238,6 +253,40 @@ describe("workflow launch params", () => {
 		);
 	});
 
+	it("forwards control defaults and overrides to retained workflow children", () => {
+		assert.deepEqual(
+			prepareWorkflowLaunchParams(
+				{ control: { needsAttentionAfterMs: 111, activeNoticeAfterMs: 222 } },
+				{ resume: "retained-run", task: "Continue", control: { activeNoticeAfterMs: 333 } },
+				"workflow-run",
+				"continue",
+			),
+			{
+				action: "resume",
+				id: "retained-run",
+				message: "Continue",
+				workflowParentRunId: "workflow-run",
+				workflowKey: "continue",
+				control: {
+					needsAttentionAfterMs: 111,
+					activeNoticeAfterMs: 333,
+				},
+			},
+		);
+	});
+
+	it("lets retained workflow child control overrides amend recovered control configs", () => {
+		const recovered = resolveControlConfig(undefined, { needsAttentionAfterMs: 111, activeNoticeAfterMs: 222 });
+		const control = resolveRevivalControlConfig({
+			recoveryControlConfig: recovered,
+			requestedControl: { activeNoticeAfterMs: 333, notifyChannels: [] },
+		});
+
+		assert.equal(control.needsAttentionAfterMs, 111);
+		assert.equal(control.activeNoticeAfterMs, 333);
+		assert.deepEqual(control.notifyChannels, []);
+	});
+
 	it("does not inherit parent deadlines for retained workflow children", () => {
 		assert.deepEqual(
 			prepareWorkflowLaunchParams(

package/dist/extensions/pi-subagents/test/unit/workflow-preflight.test.ts

@@ -13,6 +13,7 @@ import {
 	formatWorkflowPreflightWarningSummary,
 	normalizeWorkflowPreflight,
 	validateWorkflowPreflight,
+	workflowPreflightLaneForRuntimeKey,
 	workflowPreflightWarnings,
 } from "../../src/workflows/workflow-preflight.ts";
 
@@ -121,6 +122,21 @@ describe("workflow preflight metadata", () => {
 		assert.ok(WORKFLOW_PREFLIGHT_MAX_CLAIMS > 0);
 	});
 
+	it("selects exact lanes before generated or dotted-root matches", () => {
+		const overlapping = {
+			version: 1 as const,
+			coverage: "partial" as const,
+			lanes: [
+				{ key: "writer", mode: "mutation" as const },
+				{ key: "writer.quality", mode: "review" as const },
+			],
+		};
+
+		assert.equal(workflowPreflightLaneForRuntimeKey(overlapping, "writer.quality")?.mode, "review");
+		assert.equal(workflowPreflightLaneForRuntimeKey(overlapping, "writer.quality.deep", ["writer"])?.mode, "review");
+		assert.equal(workflowPreflightLaneForRuntimeKey(overlapping, "generated", ["writer"])?.mode, "mutation");
+	});
+
 	it("treats exact and direct dotted keys as declared lane stages by convention", () => {
 		const lanes = normalizeWorkflowPreflight({
 			version: 1,
@@ -151,5 +167,11 @@ describe("workflow preflight metadata", () => {
 
 		const exactTrace = [{ operation: "run", key: "audit", state: "completed" as const }];
 		assert.deepEqual(workflowPreflightWarnings(lanes, exactTrace, { settled: true }), []);
+
+		const hyphenatedTrace = [{ operation: "run", key: "audit-quality", state: "completed" as const }];
+		assert.deepEqual(workflowPreflightWarnings(lanes, hyphenatedTrace, { settled: true }), [
+			"Preflight advisory: workflow key 'audit-quality' launched without a declared lane.",
+			"Preflight advisory: declared lane 'audit' was not launched.",
+		]);
 	});
 });

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

@@ -10,7 +10,12 @@ import {
 	diffWorktrees,
 	findWorktreeTaskCwdConflict,
 	formatWorktreeDiffSummary,
+	buildWorktreeNaming,
+	normalizeWorktreeBranchPrefix,
 	resolveExpectedWorktreeAgentCwd,
+	resolveWorktreeProvider,
+	sanitizeWorktreePathComponent,
+	shouldDeferWorktreeCwd,
 	type WorktreeSetup,
 } from "../../src/runs/shared/worktree.ts";
 
@@ -50,18 +55,21 @@ function createHookScript(_repoDir: string, fileName: string, source: string): s
 const hookScriptSkip = process.platform === "win32"
 	? "Hook script execution differs on Windows CI environments."
 	: undefined;
+const worktrunkShimSkip = process.platform === "win32"
+	? "Windows Terminal installs a wt.exe app alias that can outrank test command shims."
+	: undefined;
 
 describe("worktree", () => {
 	it("createWorktrees returns expected structure", () => {
 		const repoDir = createRepo("pi-worktree-structure-");
 		let setup: WorktreeSetup | undefined;
 		try {
-			setup = createWorktrees(repoDir, "structure", 2);
+			setup = createWorktrees(repoDir, "structure", 2, { provider: "native" });
 			assert.equal(setup.worktrees.length, 2);
 			assert.equal(setup.cwd, git(repoDir, ["rev-parse", "--show-toplevel"]));
 			for (let i = 0; i < setup.worktrees.length; i++) {
 				const worktree = setup.worktrees[i]!;
-				assert.equal(worktree.branch, `pi-parallel-structure-${i}`);
+				assert.equal(worktree.branch, `pi-subagents/task-structure-s0-t${i}`);
 				assert.equal(worktree.index, i);
 				assert.equal(worktree.agentCwd, worktree.path);
 				assert.equal(worktree.nodeModulesLinked, false);
@@ -80,10 +88,11 @@ describe("worktree", () => {
 		let planned: WorktreeSetup | undefined;
 		try {
 			setup = createWorktrees(repoDir, "before-create", 1, {
+				provider: "native",
 				beforeCreate: (candidate) => {
 					planned = candidate;
 					assert.equal(fs.existsSync(candidate.worktrees[0]!.path), false);
-					assert.equal(candidate.worktrees[0]!.branch, "pi-parallel-before-create-0");
+					assert.equal(candidate.worktrees[0]!.branch, "pi-subagents/task-before-creat-s0-t0");
 				},
 			});
 			assert.equal(planned?.baseCommit, setup.baseCommit);
@@ -95,6 +104,129 @@ describe("worktree", () => {
 		}
 	});
 
+	it("records Worktrunk ownership and uses its returned path", () => {
+		try { resolveWorktreeProvider("worktrunk"); } catch { return; }
+		const repoDir = createRepo("pi-worktree-worktrunk-");
+		let setup: WorktreeSetup | undefined;
+		try {
+			setup = createWorktrees(repoDir, "worktrunk-s0", 1, {
+				provider: "worktrunk",
+				agents: ["worker"],
+				labels: ["Review API"],
+				tasks: ["Review API behavior"],
+				branchPrefix: "pi-test/",
+			});
+			const worktree = setup.worktrees[0]!;
+			assert.equal(worktree.provider, "worktrunk");
+			assert.equal(worktree.branch, "pi-test/Review-API-1f1a55a7-worktrunk-s0-t0");
+			assert.equal(worktree.naming?.requestedBranch, worktree.branch);
+			assert.ok(fs.existsSync(worktree.path));
+			assert.notEqual(worktree.path, resolveExpectedWorktreeAgentCwd(repoDir, "worktrunk-s0", 0));
+		} finally {
+			if (setup) cleanupWorktrees(setup, { kind: "setup-rollback" });
+			cleanupRepo(repoDir);
+		}
+	});
+
+	it("rejects Worktrunk responses that point at the source checkout", { skip: worktrunkShimSkip }, () => {
+		const fakeBin = fs.mkdtempSync(path.join(os.tmpdir(), "pi-worktree-fake-source-wt-"));
+		const fakeScript = path.join(fakeBin, "wt.cjs");
+		const fakeWt = path.join(fakeBin, process.platform === "win32" ? "wt.cmd" : "wt");
+		fs.writeFileSync(fakeScript, `const { spawnSync } = require("node:child_process");
+const args = process.argv.slice(2);
+if (args[0] === "--version") { console.log("wt v0.75.0"); process.exit(0); }
+if (args[0] === "switch" && args[1] === "--help") { console.log("--create --base --no-cd --no-hooks --format"); process.exit(0); }
+const repo = args[args.indexOf("-C") + 1];
+const branch = args[args.indexOf("--create") + 1];
+const base = args[args.indexOf("--base") + 1];
+const result = spawnSync("git", ["-C", repo, "checkout", "-b", branch], { encoding: "utf-8" });
+if (result.status !== 0) { process.stderr.write(result.stderr || result.stdout); process.exit(result.status || 1); }
+console.log(JSON.stringify({ action: "created", branch, path: repo, created_branch: true, base_branch: base }));
+`, "utf-8");
+		if (process.platform === "win32") fs.writeFileSync(fakeWt, `@echo off\r\n"${process.execPath}" "%~dp0wt.cjs" %*\r\n`, "utf-8");
+		else {
+			fs.writeFileSync(fakeWt, `#!/bin/sh\nexec "${process.execPath}" "${fakeScript}" "$@"\n`, "utf-8");
+			fs.chmodSync(fakeWt, 0o755);
+		}
+		const previousPath = process.env.PATH;
+		const previousWindowsPath = process.env.Path;
+		const previousPathExt = process.env.PATHEXT;
+		const repoDir = createRepo("pi-worktree-source-wt-");
+		try {
+			const originalBranch = git(repoDir, ["branch", "--show-current"]);
+			process.env.PATH = `${fakeBin}${path.delimiter}${previousPath ?? ""}`;
+			process.env.Path = `${fakeBin}${path.delimiter}${previousWindowsPath ?? previousPath ?? ""}`;
+			process.env.PATHEXT = [".CMD", ".EXE", ".BAT", previousPathExt ?? ""].filter(Boolean).join(path.delimiter);
+			assert.throws(
+				() => createWorktrees(repoDir, "source-path", 1, { provider: "worktrunk" }),
+				/source checkout path/i,
+			);
+			assert.equal(git(repoDir, ["branch", "--show-current"]), originalBranch);
+			assert.equal(git(repoDir, ["branch", "--list", "pi-subagents/task-source-path-s0-t0"]), "");
+		} finally {
+			if (previousPath === undefined) delete process.env.PATH;
+			else process.env.PATH = previousPath;
+			if (previousWindowsPath === undefined) delete process.env.Path;
+			else process.env.Path = previousWindowsPath;
+			if (previousPathExt === undefined) delete process.env.PATHEXT;
+			else process.env.PATHEXT = previousPathExt;
+			cleanupRepo(repoDir);
+			fs.rmSync(fakeBin, { recursive: true, force: true });
+		}
+	});
+
+	it("falls back to native only when Worktrunk capability probing fails", () => {
+		const fakeBin = fs.mkdtempSync(path.join(os.tmpdir(), "pi-worktree-fake-wt-"));
+		const fakeWt = path.join(fakeBin, process.platform === "win32" ? "wt.cmd" : "wt");
+		fs.writeFileSync(fakeWt, process.platform === "win32" ? "@echo not-worktrunk\r\n" : "#!/bin/sh\nprintf 'not-worktrunk\\n'\n", "utf-8");
+		if (process.platform !== "win32") fs.chmodSync(fakeWt, 0o755);
+		const previousPath = process.env.PATH;
+		const previousWindowsPath = process.env.Path;
+		const previousPathExt = process.env.PATHEXT;
+		const repoDir = createRepo("pi-worktree-provider-fallback-");
+		let setup: WorktreeSetup | undefined;
+		try {
+			process.env.PATH = `${fakeBin}${path.delimiter}${previousPath ?? ""}`;
+			process.env.Path = `${fakeBin}${path.delimiter}${previousWindowsPath ?? previousPath ?? ""}`;
+			process.env.PATHEXT = [".CMD", ".EXE", ".BAT", previousPathExt ?? ""].filter(Boolean).join(path.delimiter);
+			assert.equal(resolveWorktreeProvider(undefined), "native");
+			assert.equal(shouldDeferWorktreeCwd(undefined), true);
+			assert.equal(resolveWorktreeProvider(undefined, " "), "native");
+			assert.equal(shouldDeferWorktreeCwd(undefined, " "), false);
+			assert.throws(() => createWorktrees(repoDir, "provider-fallback", 1, { baseDir: " " }), /cannot be empty/i);
+			setup = createWorktrees(repoDir, "provider-fallback", 1);
+			assert.equal(setup.worktrees[0]?.provider, "native");
+			assert.throws(() => resolveWorktreeProvider("worktrunk"), /Worktrunk provider is unavailable/i);
+		} finally {
+			if (setup) cleanupWorktrees(setup, { kind: "setup-rollback" });
+			if (previousPath === undefined) delete process.env.PATH;
+			else process.env.PATH = previousPath;
+			if (previousWindowsPath === undefined) delete process.env.Path;
+			else process.env.Path = previousWindowsPath;
+			if (previousPathExt === undefined) delete process.env.PATHEXT;
+			else process.env.PATHEXT = previousPathExt;
+			cleanupRepo(repoDir);
+			fs.rmSync(fakeBin, { recursive: true, force: true });
+		}
+	});
+
+	it("sanitizes readable names and validates provider branch namespaces", () => {
+		const naming = buildWorktreeNaming({
+			runId: "run-s3",
+			index: 4,
+			agent: "worker",
+			task: "Fix: API / paths",
+			branchPrefix: "pi-custom",
+		});
+		assert.equal(naming.requestedBranch, "pi-custom/worker-Fix-API-paths-17ad7139-run-s3-t4");
+		assert.equal(naming.branchPrefix, "pi-custom/");
+		assert.equal(sanitizeWorktreePathComponent("..."), "task");
+		assert.ok(Buffer.byteLength(sanitizeWorktreePathComponent("é".repeat(200)), "utf-8") <= 96);
+		assert.equal(buildWorktreeNaming({ runId: "run", index: 0, agent: "worker", task: "Fix\nAPI" }).label, "worker-Fix API");
+		assert.equal(normalizeWorktreeBranchPrefix("pi-custom/"), "pi-custom/");
+		assert.throws(() => normalizeWorktreeBranchPrefix("../unsafe"), /invalid/i);
+	});
+
 	it("createWorktrees maps subdirectory cwd to each agentCwd", () => {
 		const repoDir = createRepo("pi-worktree-subdir-");
 		const nestedDir = path.join(repoDir, "packages", "app");
@@ -629,7 +761,7 @@ process.stdout.write(JSON.stringify({ syntheticPaths: [] }));
 				() => createWorktrees(repoDir, runId, 2, { setupHook: { hookPath: path.relative(repoDir, hookPath) } }),
 				/worktree setup hook failed with exit code 1/i,
 			);
-			const branchList = git(repoDir, ["branch", "--list", `pi-parallel-${runId}-*`]);
+			const branchList = git(repoDir, ["branch", "--list", "pi-subagents/task-hook-cleanup-s0-t*"]);
 			assert.equal(branchList.trim(), "", "temporary branches should be cleaned up after setup failure");
 		} finally {
 			cleanupRepo(repoDir);

package/dist/extensions/pi-zentui/README.md

@@ -14,14 +14,15 @@
 
 ## What is this?
 
-Zentui gives four Pi surfaces independent ownership and styling:
+Zentui gives Pi surfaces independent, opt-in treatments:
 
 - **Editor** — Opencode, Opencode copy-friendly, Accent Rail, and Minimalist input treatments
 - **User messages** — framed, framed copy-friendly, compact, and labeled transcript messages
+- **Thinking (Experimental)** — optional Rail, Tree, or Streaming private thinking renderers, without owning the Working line
 - **Working line** — optional ownership of Pi's complete in-progress row and settled turn summary
 - **Footer** — Pi's native Footer, a Starship-style statusline, or a hidden zero-row Footer
 
-Editor, User messages, Working line, and selector borders have independent `enabled` fields. Footer uses one `style`: `native`, `starship`, or `hidden`. Use `/zentui` to configure each component without coupling it to the others.
+Editor, User messages, Thinking (Experimental), Working line, and selector borders have independent `enabled` fields. Footer uses one `style`: `native`, `starship`, or `hidden`. Use `/zentui` to configure each component without coupling it to the others.
 
 ## Highlights
 
@@ -29,6 +30,7 @@ Editor, User messages, Working line, and selector borders have independent `enab
 | --- | --- | --- |
 | Editor | `opencode` | Opencode, copy-friendly, Accent Rail, Minimalist |
 | User messages | `framed` | Framed, copy-friendly, Compact, Labeled |
+| Thinking (Experimental) | disabled (`tree`) | Rail, Tree, Streaming |
 | Working line | disabled | Five spinner presets, live tool/time/thinking/token segments, turn summary |
 | Footer | `starship` | Native, Starship, Hidden |
 | Selector borders | `zentui` | Independent enablement and color source |
@@ -87,7 +89,7 @@ pi install git:github.com/lmilojevicc/pi-zentui
 
 ## Configure
 
-Run `/zentui` inside Pi to configure Appearance, Editor, User messages, Working line, Footer, Segments, Git, and Extensions. Use `Tab` and `Shift+Tab` to switch sections. Changes are applied live and saved to:
+Run `/zentui` inside Pi to configure Appearance, Editor, User messages, Thinking (Experimental), Working line, Footer, Segments, Git, and Extensions. Use `Tab` and `Shift+Tab` to switch sections. Most changes apply live. Active Streaming can switch live to Rail or Tree, and Rail and Tree can switch live between each other. Entering Streaming from a structural mode, first enable, and re-enable after a live disable require restarting Pi. Configuration is saved to:
 
 ```text
 ~/.pi/agent/zentui.json
@@ -106,6 +108,10 @@ A small starter config:
       "enabled": true,
       "style": "framed"
     },
+    "thinkingSteps": {
+      "enabled": false,
+      "mode": "tree"
+    },
     "workingLine": {
       "enabled": false
     },
@@ -138,7 +144,13 @@ Useful shortcuts:
 /zentui format clear
 ```
 
-Pi 0.84 also provides a native fullscreen TUI with a sticky editor and Footer. Zentui does not enable it automatically; select fullscreen from Pi's `/settings`, set `"tuiMode": "fullscreen"` in Pi settings, or launch Pi with `--tui-mode fullscreen`.
+**Thinking (Experimental)** uses one private `AssistantMessageComponent` renderer for Rail, Tree, and Streaming, tested against exact Pi versions 0.80.5, 0.82.1, 0.83.0, 0.84.0, and 0.84.4. It is disabled by default and may break after Pi updates. Zentui installs an enabled startup mode before transcript restoration. A healthy installed controller lets active Streaming switch live to Rail or Tree, and lets Rail and Tree switch live between each other, without reinstalling its patch. Entering Streaming from Rail or Tree saves the choice but keeps the active structural mode until restart. Disabling live restores native thinking and releases Streaming resources. First enable and re-enable after a live disable are also restart-gated. Mode changes while disabled only preconfigure the next enable. Startup failures, missing constructors, incompatible private child layouts, parser limits, theme/render/width errors, and displaced patch ownership fail open to complete native thinking. If cleanup throws while leaving Streaming, disabling still restores native thinking and a structural selection still becomes active; the successful change warns that Streaming is unavailable for the rest of the session.
+
+Rail shows every parsed label in each native contiguous thinking run (`│ Label`, with only the open final phase shown as `│ • Label`). Tree independently shows the latest five labels in each run (`├─ · Label`, settled `└─ · Label`, open `└─ • Label`); it never aggregates across intervening text or tool blocks. Rail and Tree follow Pi's thinking visibility. Complete strict SGR styling is stripped before parsing; every other terminal control and unsafe or unstructured content keeps the complete run native. Labels are rendered by fresh host-shaped Pi Markdown instances before cropping, so emphasis, code, links, HTML, LaTeX, custom transforms, and native `thinkingText` styling remain host-controlled. Every label occupies one terminal row: ANSI/OSC/grapheme-aware cropping adds `…` only when needed. Native horizontal padding stays external. Connectors are styled directly with the current theme's `accent` callback on every render, so custom themes control them independently. Hidden native thinking remains hidden and keeps Pi's native hidden label.
+
+Streaming retains Pi's host-rendered final five rows under `Thinking 7.1s`, folds completed reasoning under `Thought` or current-session `Thought for 12.3s`, and owns the configured thinking-toggle binding (Ctrl+T by default) only when started in Streaming. Its input listener and timer are acquired only for an enabled Streaming session start; startup acquisition failure uses native thinking and marks Streaming unavailable. Restored completions cannot recover a duration because Pi does not persist the thinking-end timestamp. Expand/refold and lifecycle tracking are bounded to 256 retained assistant components; evicted entries are first restored natively. All modes restore/dispose on shutdown. Thinking (Experimental) never writes the Working line and does not change its existing **Thinking time** option, working text, Footer, Editor, statuses, or model behavior.
+
+Pi 0.84 also provides a native fullscreen TUI with a sticky editor and Footer. Pi 0.84.4 is covered by a fullscreen live-transition PTY smoke in addition to the standard matrix. Zentui does not enable fullscreen automatically; select it from Pi's `/settings`, set `"tuiMode": "fullscreen"` in Pi settings, or launch Pi with `--tui-mode fullscreen`.
 
 ## Requirements
 
@@ -180,8 +192,10 @@ See [CONTRIBUTING.md](https://github.com/lmilojevicc/pi-zentui/blob/main/CONTRIB
 - [Opencode](https://github.com/anomalyco/opencode) — inspiration for the Opencode editor treatment
 - [Oh My Pi (`omp`)](https://github.com/can1357/oh-my-pi) by [Can Bölük](https://github.com/can1357) — visual inspiration for the filled, single-left-rail Accent Rail editor
 - [Pi Custom Input](https://github.com/VinhLe1410/pi-custom-input) by [Vinh Le](https://github.com/VinhLe1410) — visual inspiration for Minimalist's framed, border-embedded session, model, context, Git, and path metadata
+- [Pi Thinking Steps](https://github.com/crustyhacker/pi-thinking-steps) by Marc Mironescu / FluxGear — structural-step parsing and the Rail/Tree visual language; adapted in Thinking (Experimental) under the MIT License
+- [Pi Thinking Fold](https://github.com/99percentpeople/pi-extensions/tree/master/extensions/thinking-fold) by [Zach Yuen](https://github.com/99percentpeople) — native rendered-row folding, timing, expand/refold behavior, and fail-open compatibility patterns; adapted in Thinking (Experimental) under the MIT License
 
-Zentui's implementations are independent; these credits acknowledge product and visual inspiration rather than source-code reuse.
+Most Zentui implementations are independent; these credits acknowledge product and visual inspiration. Thinking (Experimental) also adapts MIT-licensed implementation work from Pi Thinking Steps and Pi Thinking Fold. Their complete copyright and permission notices are retained in the packaged [`thinking-experimental.ts`](./extensions/zentui/thinking-experimental.ts) source.
 
 ## License