@selesai/code 0.9.10 → 0.9.12

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

@@ -95,10 +95,11 @@ describe("workflow chat progress policy", () => {
 			assert.equal(isSameGitRepository(repo, other), false);
 
 			assert.equal(resolveWorkflowChatProgress({ requested: "auto", parentCwd: repo, workflowCwd: worktree, background: false }).projection?.mode, "live-card");
-			assert.equal(resolveWorkflowChatProgress({ requested: "auto", parentCwd: repo, workflowCwd: worktree, background: true }).projection?.mode, "milestones");
-			assert.equal(resolveWorkflowChatProgress({ requested: "auto", parentCwd: repo, workflowCwd: other, background: false }).projection?.mode, "terminal");
+			assert.equal(resolveWorkflowChatProgress({ requested: "auto", parentCwd: repo, workflowCwd: worktree, background: true }).projection?.mode, "off");
+			assert.equal(resolveWorkflowChatProgress({ requested: "auto", parentCwd: repo, workflowCwd: other, background: false }).projection?.mode, "off");
 			assert.match(resolveWorkflowChatProgress({ requested: "live-card", parentCwd: repo, workflowCwd: other, background: false }).error ?? "", /same Git repository/i);
-			assert.match(resolveWorkflowChatProgress({ requested: "terminal", parentCwd: repo, workflowCwd: repo, background: false }).projection?.mode ?? "", /terminal/);
+			assert.match(resolveWorkflowChatProgress({ requested: "live-card", parentCwd: repo, workflowCwd: repo, background: true }).error ?? "", /omit chatProgress or use auto\/off.*async:false only when the parent must block/i);
+			assert.match(resolveWorkflowChatProgress({ requested: "terminal", parentCwd: repo, workflowCwd: repo, background: false }).error ?? "", /one of: auto, off, live-card/i);
 		} finally {
 			try { git(repo, ["worktree", "remove", "--force", worktree]); } catch {}
 			fs.rmSync(repo, { recursive: true, force: true });
@@ -209,8 +210,8 @@ describe("workflow chat progress rendering", () => {
 		try {
 			const location = {
 				projectRoot: root,
-				missionDir: path.join(root, ".pi/subagents", "missions"),
-				globalIndexDir: path.join(root, ".pi/subagents", "mission-index"),
+				missionDir: path.join(root, ".pi-subagents", "missions"),
+				globalIndexDir: path.join(root, ".pi-subagents", "mission-index"),
 				writeGlobalIndex: false,
 			};
 			const mission = createMission(location, { title: "Workflow", objective: "Track child" });
@@ -271,29 +272,56 @@ describe("workflow chat progress rendering", () => {
 			state: "detached",
 			phase: "Decision",
 			label: "supervisor handoff",
+			runId: "child-detached-123456",
 			error: "Detached for intercom coordination. Reply to the supervisor request first.",
 		}];
 		const rows = buildWorkflowChatProgressRows(trace);
 		assert.equal(rows[0]?.state, "detached");
 
 		const text = componentText(renderSubagentResult({
-			content: [{ type: "text", text: "Workflow paused." }],
+			content: [{ type: "text", text: "Workflow failed: Run 'detaches' detached for intercom coordination." }],
+			isError: true,
 			details: {
 				mode: "workflow",
-				runId: "wf_detached",
+				runId: "wf_detached_123456",
 				results: [],
 				chatProgress: { mode: "live-card", repoRelation: "same", repoLabel: "pi-subagents" },
 				workflow: { trace, emits: [], console: [] },
 			},
 		}, { expanded: false }, theme as any));
 
-		assert.match(text, /workflow wf_detached .* same repo .* paused/);
+		assert.match(text, /workflow wf_detached_ .* same repo .* paused/);
 		assert.match(text, /Phase  Decision/);
-		assert.match(text, /detached\s+detaches supervisor handoff .* Detached for intercom coordination/);
+		assert.match(text, /detached\s+detaches supervisor handoff \[child-de\] .* Detached for intercom coordination/);
 		assert.doesNotMatch(text, /running\s+detaches/);
 		assert.doesNotMatch(text, /failed\s+detaches/);
 	});
 
+	it("keeps mixed detached and failed workflow traces failed", () => {
+		const text = componentText(renderSubagentResult({
+			content: [{ type: "text", text: "Workflow failed: child failed after a detached sibling." }],
+			isError: true,
+			details: {
+				mode: "workflow",
+				runId: "wf_mixed_failure",
+				results: [],
+				chatProgress: { mode: "live-card", repoRelation: "same", repoLabel: "pi-subagents" },
+				workflow: {
+					trace: [
+						{ operation: "run", key: "handoff", state: "detached", runId: "child-detached", error: "Detached for supervisor handoff." },
+						{ operation: "run", key: "tests", state: "failed", runId: "child-failed", error: "unit test failed" },
+					],
+					emits: [],
+					console: [],
+				},
+			},
+		}, { expanded: false }, theme as any));
+
+		assert.match(text, /workflow wf_mixed_fai .* same repo .* failed/);
+		assert.match(text, /detached\s+handoff .* Detached for supervisor handoff/);
+		assert.match(text, /failed\s+tests .* unit test failed/);
+	});
+
 	it("applies main-window density settings to collapsed workflow live cards", () => {
 		const trace = Array.from({ length: 10 }, (_, index) => ({
 			operation: "run" as const,

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

@@ -0,0 +1,302 @@
+import assert from "node:assert/strict";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { describe, it } from "node:test";
+import { applyDetachedChildToPausedWorkflow, promotePausedWorkflowIfSettled, reconcileDetachedWorkflowChildCompletion } from "../../src/runs/foreground/workflow-detach-reconcile.ts";
+import { DIRS, type AsyncStatus, type IntercomEventBus, type SubagentState } from "../../src/shared/types.ts";
+import { buildWorkflowReceipt, writeWorkflowReceipt } from "../../src/workflows/workflow-receipt.ts";
+
+function pausedWorkflow(childRunId: string, extra?: Partial<NonNullable<AsyncStatus["steps"]>[number]>): AsyncStatus {
+	return {
+		runId: "workflow-1",
+		mode: "workflow",
+		state: "paused",
+		startedAt: 1,
+		activityState: "needs_attention",
+		error: "Run 'worker' detached for intercom coordination.",
+		steps: [{
+			agent: "worker",
+			workflowKey: "detaches",
+			runId: childRunId,
+			status: "paused",
+			activityState: "needs_attention",
+			currentTool: "contact_supervisor",
+			...extra,
+		}],
+	};
+}
+
+describe("applyDetachedChildToPausedWorkflow", () => {
+	it("fails closed when a detached child succeeds without persisted workflow continuation", () => {
+		const next = applyDetachedChildToPausedWorkflow(pausedWorkflow("child-1"), {
+			childRunId: "child-1",
+			result: { exitCode: 0, sessionFile: "/tmp/child.jsonl" },
+		});
+		assert.equal(next?.state, "failed");
+		assert.equal(next?.activityState, undefined);
+		assert.match(next?.error ?? "", /unsupported-continuation/);
+		assert.equal(next?.steps?.[0]?.status, "completed");
+		assert.equal(next?.steps?.[0]?.activityState, undefined);
+		assert.equal(next?.steps?.[0]?.sessionFile, "/tmp/child.jsonl");
+	});
+
+	it("fails a paused workflow when its detached child fails", () => {
+		const next = applyDetachedChildToPausedWorkflow(pausedWorkflow("child-1"), {
+			childRunId: "child-1",
+			result: { exitCode: 1, error: "boom" },
+		});
+		assert.equal(next?.state, "failed");
+		assert.equal(next?.error, "boom");
+		assert.equal(next?.steps?.[0]?.status, "failed");
+		assert.equal(next?.steps?.[0]?.error, "boom");
+	});
+
+	it("replaces stale detach errors when a detached child is interrupted", () => {
+		const next = applyDetachedChildToPausedWorkflow(pausedWorkflow("child-1"), {
+			childRunId: "child-1",
+			result: { exitCode: 0, interrupted: true },
+		});
+		assert.equal(next?.state, "failed");
+		assert.equal(next?.error, "Interrupted. Waiting for explicit next action.");
+		assert.equal(next?.steps?.[0]?.status, "failed");
+		assert.equal(next?.steps?.[0]?.error, "Interrupted. Waiting for explicit next action.");
+	});
+
+	it("preserves a sibling failure when a detached child is interrupted", () => {
+		const status = pausedWorkflow("child-1");
+		status.error = "sibling boom";
+		status.steps!.push({
+			agent: "other",
+			workflowKey: "fails",
+			runId: "child-2",
+			status: "failed",
+			error: "sibling boom",
+		});
+		const next = applyDetachedChildToPausedWorkflow(status, {
+			childRunId: "child-1",
+			result: { exitCode: 0, interrupted: true },
+		});
+		assert.equal(next?.state, "failed");
+		assert.equal(next?.error, "sibling boom");
+		assert.equal(next?.steps?.find((step) => step.workflowKey === "detaches")?.error, "Interrupted. Waiting for explicit next action.");
+	});
+
+	it("keeps the workflow paused while another detached child still needs attention", () => {
+		const status = pausedWorkflow("child-1");
+		status.steps!.push({
+			agent: "other",
+			workflowKey: "also",
+			runId: "child-2",
+			status: "paused",
+			activityState: "needs_attention",
+		});
+		const next = applyDetachedChildToPausedWorkflow(status, {
+			childRunId: "child-1",
+			result: { exitCode: 0 },
+		});
+		assert.equal(next?.state, "paused");
+		assert.equal(next?.activityState, "needs_attention");
+		assert.equal(next?.steps?.[0]?.status, "completed");
+		assert.equal(next?.steps?.[1]?.status, "paused");
+	});
+
+	it("ignores failed workflows and unknown children", () => {
+		assert.equal(applyDetachedChildToPausedWorkflow({ ...pausedWorkflow("child-1"), state: "failed" }, {
+			childRunId: "child-1",
+			result: { exitCode: 0 },
+		}), undefined);
+		assert.equal(applyDetachedChildToPausedWorkflow(pausedWorkflow("child-1"), {
+			childRunId: "missing",
+			result: { exitCode: 0 },
+		}), undefined);
+	});
+
+	it("fails closed when the matching step already settled", () => {
+		const status = pausedWorkflow("child-1");
+		status.steps![0]!.status = "completed";
+		delete status.steps![0]!.activityState;
+		const next = applyDetachedChildToPausedWorkflow(status, {
+			childRunId: "child-1",
+			result: { exitCode: 0, sessionFile: "/tmp/child.jsonl" },
+		});
+		assert.equal(next?.state, "failed");
+		assert.match(next?.error ?? "", /unsupported-continuation/);
+		assert.equal(promotePausedWorkflowIfSettled(status)?.state, "failed");
+	});
+
+	it("fails closed after a detached child settles when an aborted sibling is stopped", () => {
+		const status = pausedWorkflow("child-1");
+		status.steps!.push({
+			agent: "other",
+			workflowKey: "slow",
+			runId: "child-2",
+			status: "stopped",
+			stopped: true,
+		});
+		const next = applyDetachedChildToPausedWorkflow(status, {
+			childRunId: "child-1",
+			result: { exitCode: 0 },
+		});
+		assert.equal(next?.state, "failed");
+		assert.match(next?.error ?? "", /unsupported-continuation/);
+		assert.equal(next?.steps?.[1]?.status, "stopped");
+	});
+});
+
+describe("reconcileDetachedWorkflowChildCompletion", () => {
+	it("publishes a terminal result when the paused result file is already gone", () => {
+		const workflowRunId = "workflow-missing-result";
+		const asyncDir = path.join(DIRS.async, workflowRunId);
+		fs.mkdirSync(asyncDir, { recursive: true });
+		fs.mkdirSync(DIRS.results, { recursive: true });
+		const status = { ...pausedWorkflow("child-1"), runId: workflowRunId, sessionId: "session-1" };
+		fs.writeFileSync(path.join(asyncDir, "status.json"), JSON.stringify(status), "utf-8");
+		writeWorkflowReceipt(asyncDir, buildWorkflowReceipt({
+			workflowRunId,
+			state: "paused",
+			children: [{
+				key: "detaches",
+				ok: false,
+				agent: "worker",
+				runId: "child-1",
+				output: "paused",
+				detached: true,
+				artifactPaths: [],
+				resumability: { state: "not-resumable", reason: "child detached" },
+				continuation: { runIds: ["child-1"] },
+			}],
+		}));
+		const state = {
+			asyncJobs: new Map([[workflowRunId, { asyncId: workflowRunId, asyncDir, status: "paused" as const }]]),
+		} as SubagentState;
+		assert.equal(reconcileDetachedWorkflowChildCompletion({
+			state,
+			workflowRunId,
+			childRunId: "child-1",
+			result: { index: 0, agent: "worker", task: "t", exitCode: 0, usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, turns: 0 } },
+		}), true);
+		const published = JSON.parse(fs.readFileSync(path.join(DIRS.results, `${workflowRunId}.json`), "utf-8")) as { state?: string; success?: boolean; error?: string; sessionId?: string; workflowReceipt?: { receipt?: { state?: string; entries?: Record<string, { resumability?: { state?: string; reason?: string } }> } } };
+		assert.equal(published.state, "failed");
+		assert.equal(published.success, false);
+		assert.match(published.error ?? "", /unsupported-continuation/);
+		assert.equal(published.sessionId, "session-1");
+		assert.equal(published.workflowReceipt?.receipt?.state, "failed");
+		assert.equal(published.workflowReceipt?.receipt?.entries?.detaches?.resumability?.state, "not-resumable");
+		assert.match(published.workflowReceipt?.receipt?.entries?.detaches?.resumability?.reason ?? "", /not found|Status file|too short/);
+		const events = fs.readFileSync(path.join(asyncDir, "events.jsonl"), "utf-8");
+		assert.match(events, /"type":"subagent.workflow.completed"/);
+		assert.match(events, /"state":"failed"/);
+	});
+
+	it("publishes detached completion when the workflow receipt is malformed", () => {
+		const workflowRunId = "workflow-malformed-receipt";
+		const asyncDir = path.join(DIRS.async, workflowRunId);
+		fs.mkdirSync(asyncDir, { recursive: true });
+		fs.mkdirSync(DIRS.results, { recursive: true });
+		const status = { ...pausedWorkflow("child-1"), runId: workflowRunId, sessionId: "session-1" };
+		fs.writeFileSync(path.join(asyncDir, "status.json"), JSON.stringify(status), "utf-8");
+		fs.writeFileSync(path.join(asyncDir, "workflow-receipt.json"), JSON.stringify({ version: 1, workflowRunId, state: "paused", createdAt: 1, entries: { detaches: { key: "wrong" } } }), "utf-8");
+		const state = {
+			asyncJobs: new Map([[workflowRunId, { asyncId: workflowRunId, asyncDir, status: "paused" as const }]]),
+		} as SubagentState;
+
+		assert.equal(reconcileDetachedWorkflowChildCompletion({
+			state,
+			workflowRunId,
+			childRunId: "child-1",
+			result: { index: 0, agent: "worker", task: "t", exitCode: 0, usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, turns: 0 } },
+		}), true);
+
+		const published = JSON.parse(fs.readFileSync(path.join(DIRS.results, `${workflowRunId}.json`), "utf-8")) as { state?: string; success?: boolean; error?: string; workflowReceipt?: unknown };
+		assert.equal(published.state, "failed");
+		assert.equal(published.success, false);
+		assert.match(published.error ?? "", /unsupported-continuation/);
+		assert.equal(published.workflowReceipt, undefined);
+		const events = fs.readFileSync(path.join(asyncDir, "events.jsonl"), "utf-8");
+		assert.match(events, /"type":"subagent.workflow.receipt_write_failed"/);
+		assert.match(events, /"type":"subagent.workflow.completed"/);
+	});
+
+	it("publishes detached completion when receipt error journaling fails", () => {
+		const workflowRunId = "workflow-receipt-journal-fails";
+		const asyncDir = path.join(DIRS.async, workflowRunId);
+		fs.rmSync(asyncDir, { recursive: true, force: true });
+		fs.mkdirSync(asyncDir, { recursive: true });
+		fs.mkdirSync(DIRS.results, { recursive: true });
+		const status = { ...pausedWorkflow("child-1"), runId: workflowRunId, sessionId: "session-1" };
+		fs.writeFileSync(path.join(asyncDir, "status.json"), JSON.stringify(status), "utf-8");
+		fs.writeFileSync(path.join(asyncDir, "workflow-receipt.json"), JSON.stringify({ version: 1, workflowRunId, state: "paused", createdAt: 1, entries: { detaches: { key: "wrong" } } }), "utf-8");
+		fs.mkdirSync(path.join(asyncDir, "events.jsonl"));
+		const state = {
+			asyncJobs: new Map([[workflowRunId, { asyncId: workflowRunId, asyncDir, status: "paused" as const }]]),
+		} as SubagentState;
+		let emitted: { name: string; payload: unknown } | undefined;
+		const originalConsoleError = console.error;
+		console.error = () => undefined;
+		try {
+			assert.equal(reconcileDetachedWorkflowChildCompletion({
+				state,
+				workflowRunId,
+				childRunId: "child-1",
+				result: { index: 0, agent: "worker", task: "t", exitCode: 0, usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, turns: 0 } },
+				events: { emit: (name, payload) => { emitted = { name, payload }; } } as IntercomEventBus,
+			}), true);
+		} finally {
+			console.error = originalConsoleError;
+		}
+
+		const published = JSON.parse(fs.readFileSync(path.join(DIRS.results, `${workflowRunId}.json`), "utf-8")) as { state?: string; success?: boolean; error?: string; workflowReceipt?: unknown; reconciledFromDetachedChild?: string };
+		assert.equal(published.state, "failed");
+		assert.equal(published.success, false);
+		assert.match(published.error ?? "", /unsupported-continuation/);
+		assert.equal(published.workflowReceipt, undefined);
+		assert.equal(published.reconciledFromDetachedChild, "child-1");
+		assert.equal(emitted?.name, "subagent:async-complete");
+		assert.deepEqual(emitted?.payload, {
+			id: workflowRunId,
+			runId: workflowRunId,
+			source: "async",
+			mode: "workflow",
+			agent: "workflow",
+			success: false,
+			state: "failed",
+			summary: "unsupported-continuation: detached workflow child settled, but JavaScript workflow continuation was not persisted. Resume the workflow explicitly instead of treating the completed child as top-level workflow completion.",
+			reconciledFromDetachedChild: "child-1",
+			results: [{ workflowKey: "detaches", agent: "worker", runId: "child-1", success: true, output: "", outputState: "absent" }],
+			sessionId: "session-1",
+			completionOwnerId: undefined,
+			timestamp: (emitted?.payload as { timestamp?: number }).timestamp,
+			triggerTurn: true,
+		});
+	});
+
+	it("does not log workflow completion while another detached child is still open", () => {
+		const workflowRunId = "workflow-still-paused";
+		const asyncDir = path.join(DIRS.async, workflowRunId);
+		fs.mkdirSync(asyncDir, { recursive: true });
+		fs.mkdirSync(DIRS.results, { recursive: true });
+		const status = pausedWorkflow("child-1");
+		status.runId = workflowRunId;
+		status.sessionId = "session-1";
+		status.steps!.push({
+			agent: "other",
+			workflowKey: "also",
+			runId: "child-2",
+			status: "paused",
+			activityState: "needs_attention",
+		});
+		fs.writeFileSync(path.join(asyncDir, "status.json"), JSON.stringify(status), "utf-8");
+		const state = {
+			asyncJobs: new Map([[workflowRunId, { asyncId: workflowRunId, asyncDir, status: "paused" as const }]]),
+		} as SubagentState;
+		assert.equal(reconcileDetachedWorkflowChildCompletion({
+			state,
+			workflowRunId,
+			childRunId: "child-1",
+			result: { index: 0, agent: "worker", task: "t", exitCode: 0, usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, turns: 0 } },
+		}), true);
+		assert.equal(fs.existsSync(path.join(asyncDir, "events.jsonl")), false);
+		const published = JSON.parse(fs.readFileSync(path.join(DIRS.results, `${workflowRunId}.json`), "utf-8")) as { state?: string };
+		assert.equal(published.state, "paused");
+	});
+});

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

@@ -1,6 +1,6 @@
 import assert from "node:assert/strict";
 import { describe, it } from "node:test";
-import { prepareWorkflowLaunchParams } from "../../src/runs/foreground/subagent-executor.ts";
+import { prepareWorkflowLaunchParams, sanitizeRunPathSegment } from "../../src/runs/foreground/subagent-executor.ts";
 
 describe("workflow launch params", () => {
 	it("keeps omitted workflow child async foreground", () => {
@@ -21,6 +21,40 @@ describe("workflow launch params", () => {
 		);
 	});
 
+	it("passes an omitted child timeout parent deadline for default resolution", () => {
+		const parentDeadlineAt = Date.now() + 60_000;
+		const params = prepareWorkflowLaunchParams(
+			{},
+			{ agent: "worker", task: "Run" },
+			"workflow-run",
+			"run",
+			{ parentDeadlineAt },
+		);
+		assert.equal(params.async, false);
+		assert.equal(params.timeoutMs, undefined);
+		assert.equal(params.workflowParentDeadlineAt, parentDeadlineAt);
+	});
+
+	it("preserves explicit child timeout aliases over the parent deadline", () => {
+		const parentDeadlineAt = Date.now() + 60_000;
+		assert.equal(prepareWorkflowLaunchParams(
+			{},
+			{ agent: "worker", task: "Run", timeoutMs: 90_000 },
+			"workflow-run",
+			"timeout",
+			{ parentDeadlineAt },
+		).timeoutMs, 90_000);
+		const maxRuntimeParams = prepareWorkflowLaunchParams(
+			{},
+			{ agent: "worker", task: "Run", maxRuntimeMs: 90_000 },
+			"workflow-run",
+			"max-runtime",
+			{ parentDeadlineAt },
+		);
+		assert.equal(maxRuntimeParams.maxRuntimeMs, 90_000);
+		assert.equal(maxRuntimeParams.timeoutMs, undefined);
+	});
+
 	it("preserves explicit async workflow children", () => {
 		assert.deepEqual(
 			prepareWorkflowLaunchParams(
@@ -39,6 +73,58 @@ describe("workflow launch params", () => {
 		);
 	});
 
+	it("runs omitted external workflow children async while preserving awaited semantics", () => {
+		assert.deepEqual(
+			prepareWorkflowLaunchParams(
+				{},
+				{ agent: "gpt-pro", task: "Check weather" },
+				"workflow-run",
+				"weather",
+				{ externalAsyncRequired: true },
+			),
+			{
+				agent: "gpt-pro",
+				task: "Check weather",
+				async: true,
+				workflowAwaitAsync: true,
+				workflowParentRunId: "workflow-run",
+				workflowKey: "weather",
+			},
+		);
+		assert.deepEqual(
+			prepareWorkflowLaunchParams(
+				{},
+				{ agent: "gpt-pro", task: "Check weather", async: true },
+				"workflow-run",
+				"weather",
+				{ externalAsyncRequired: true },
+			),
+			{
+				agent: "gpt-pro",
+				task: "Check weather",
+				async: true,
+				workflowParentRunId: "workflow-run",
+				workflowKey: "weather",
+			},
+		);
+		assert.deepEqual(
+			prepareWorkflowLaunchParams(
+				{},
+				{ agent: "gpt-pro", task: "Check weather", async: false },
+				"workflow-run",
+				"weather",
+				{ externalAsyncRequired: true },
+			),
+			{
+				agent: "gpt-pro",
+				task: "Check weather",
+				async: false,
+				workflowParentRunId: "workflow-run",
+				workflowKey: "weather",
+			},
+		);
+	});
+
 	it("keeps a bridge override scoped to the target workflow child", () => {
 		assert.deepEqual(
 			prepareWorkflowLaunchParams(
@@ -59,7 +145,14 @@ describe("workflow launch params", () => {
 		assert.equal(prepareWorkflowLaunchParams({}, { agent: "worker", task: "Run" }, "workflow-run", "sibling").intercomBridge, undefined);
 	});
 
-	it("places workflow child gates inside managed worktree tasks", () => {
+	it("canonicalizes child extension bindings without leaking them to siblings", () => {
+		const bindings = { "shepherd.dispatch/1": { writeScope: ["src/a.ts"], role: "coder" } };
+		const child = prepareWorkflowLaunchParams({ extensionBindings: { "defaults.policy/1": true } }, { agent: "worker", task: "Run", extensionBindings: bindings }, "workflow-run", "bound");
+		assert.deepEqual(child.extensionBindings, bindings);
+		assert.equal(prepareWorkflowLaunchParams({}, { agent: "worker", task: "Run" }, "workflow-run", "plain").extensionBindings, undefined);
+	});
+
+	it("keeps managed worktree children on the single-run contract", () => {
 		assert.deepEqual(
 			prepareWorkflowLaunchParams(
 				{},
@@ -68,15 +161,13 @@ describe("workflow launch params", () => {
 				"gated",
 			),
 			{
+				agent: "worker",
+				task: "Implement",
 				worktree: true,
 				async: false,
 				workflowParentRunId: "workflow-run",
 				workflowKey: "gated",
-				tasks: [{
-					agent: "worker",
-					task: "Implement",
-					acceptance: { level: "verified", verify: [{ id: "gate", command: "npm test" }] },
-				}],
+				acceptance: { level: "verified", verify: [{ id: "gate", command: "npm test" }] },
 			},
 		);
 	});
@@ -100,6 +191,44 @@ describe("workflow launch params", () => {
 		);
 	});
 
+	it("does not inherit parent deadlines for retained workflow children", () => {
+		assert.deepEqual(
+			prepareWorkflowLaunchParams(
+				{},
+				{ resume: "retained-run", task: "Continue" },
+				"workflow-run",
+				"continue",
+				{ parentDeadlineAt: Date.now() + 60_000 },
+			),
+			{
+				action: "resume",
+				id: "retained-run",
+				message: "Continue",
+				workflowParentRunId: "workflow-run",
+				workflowKey: "continue",
+			},
+		);
+	});
+
+	it("preserves worktree isolation for retained workflow children", () => {
+		assert.deepEqual(
+			prepareWorkflowLaunchParams(
+				{},
+				{ resume: "retained-run", task: "Continue", worktree: true },
+				"workflow-run",
+				"continue",
+			),
+			{
+				action: "resume",
+				id: "retained-run",
+				message: "Continue",
+				workflowParentRunId: "workflow-run",
+				workflowKey: "continue",
+				worktree: true,
+			},
+		);
+	});
+
 	it("rejects gate defaults on retained resume items", () => {
 		assert.throws(
 			() => prepareWorkflowLaunchParams(
@@ -121,6 +250,15 @@ describe("workflow launch params", () => {
 		);
 	});
 
+	it("rejects extension binding amendments on retained resume items", () => {
+		assert.throws(() => prepareWorkflowLaunchParams(
+			{ extensionBindings: { "defaults.policy/1": true } },
+			{ resume: "retained-run", task: "Continue" },
+			"workflow-run",
+			"continue",
+		), /original retained child binding/);
+	});
+
 	it("preserves execution limits and fan-out identity when routing retained resume items", () => {
 		assert.deepEqual(
 			prepareWorkflowLaunchParams(
@@ -150,4 +288,26 @@ describe("workflow launch params", () => {
 			},
 		);
 	});
+
+	describe("sanitizeRunPathSegment", () => {
+		it("replaces Windows-invalid characters and trims separators", () => {
+			assert.equal(sanitizeRunPathSegment("call_VfdHQygxGeL1L49ez04A4tf7|WtnJ9gVpB/jdQGWbnKhfMgDqPGUGmNw"), "call_VfdHQygxGeL1L49ez04A4tf7_WtnJ9gVpB_jdQGWbnKhfMgDqPGUGmNw");
+			assert.equal(sanitizeRunPathSegment(":::path//sub?*<file>|name:::"), "path_sub_file_name");
+			assert.equal(sanitizeRunPathSegment("   ___invalid___   "), "invalid");
+		});
+
+		it("falls back to unknown for empty or all-invalid strings", () => {
+			assert.equal(sanitizeRunPathSegment(""), "unknown");
+			assert.equal(sanitizeRunPathSegment("   "), "unknown");
+			assert.equal(sanitizeRunPathSegment("???///|||"), "unknown");
+		});
+
+		it("bounds oversized segments to the maximum byte length", () => {
+			const longId = "a".repeat(200);
+			const sanitized = sanitizeRunPathSegment(longId, 120);
+			assert.equal(sanitized.length, 120);
+			assert.equal(Buffer.byteLength(sanitized, "utf-8"), 120);
+			assert.equal(sanitized, "a".repeat(120));
+		});
+	});
 });