@selesai/code 0.13.40 → 0.14.3

package/dist/extensions/pi-subagents/test/integration/inline-workflow-visibility.test.ts

@@ -0,0 +1,351 @@
+import assert from "node:assert/strict";
+import { it } from "node:test";
+import { Editor } from "@earendil-works/pi-tui";
+import type { ExtensionContext } from "@selesai/code";
+import type { AsyncJobState, SubagentState } from "../../src/shared/types.ts";
+import { WIDGET_KEY } from "../../src/shared/types.ts";
+import { FLEET_STATUS_WIDGET_KEY, SubagentFleetStatus } from "../../src/tui/fleet-status.ts";
+import { inlineWorkflowRenderKey, renderWidget, setInlineWorkflowCoverage } from "../../src/tui/render.ts";
+
+const theme = { fg: (_name: string, text: string) => text, bg: (_name: string, text: string) => text, bold: (text: string) => text };
+type Mounted = { render(width: number): string[]; dispose?(): void };
+function harness(maxAgentRows = 6, inspector: () => Promise<void> = async () => {}) {
+	const job: AsyncJobState = { asyncId: "workflow", asyncDir: "/tmp/workflow", mode: "workflow", status: "running", startedAt: 1_000,
+		steps: [{ workflowKey: "lane-a", agent: "unique-worker", status: "running" }] };
+	const state = { asyncJobs: new Map([[job.asyncId, job]]), foregroundControls: new Map() } as unknown as SubagentState;
+	const mounted = new Map<string, Mounted>();
+	let requests = 0;
+	let coverageCalls = 0;
+	let expanded = false;
+	const tui = { requestRender() { requests++; }, focusedComponent: Object.create(Editor.prototype) };
+	const ctx = { hasUI: true, ui: { theme, getToolsExpanded: () => expanded, getEditorText: () => "", onTerminalInput: () => () => {}, notify() {},
+		setWidget(key: string, factory: ((tui: unknown, theme: unknown) => Mounted) | undefined) {
+			mounted.get(key)?.dispose?.(); mounted.delete(key);
+			if (factory) mounted.set(key, factory(tui, theme));
+		} } } as unknown as ExtensionContext;
+	const fleet = new SubagentFleetStatus(state, inspector, { refreshMs: 60_000, maxAgentRows, onWorkflowCoverageChange(ui, coverage) {
+		coverageCalls++;
+		setInlineWorkflowCoverage(ui, coverage);
+	} });
+	fleet.setContext(ctx);
+	renderWidget(ctx, [job]);
+	return { job, state, ctx, fleet, mounted, get requests() { return requests; }, get coverageCalls() { return coverageCalls; }, setExpanded(value: boolean) { expanded = value; },
+		resetRequests() { requests = 0; },
+		asyncText: () => mounted.get(WIDGET_KEY)!.render(240).join("\n"),
+		roster: (width = 240) => mounted.get(FLEET_STATUS_WIDGET_KEY)!.render(width).join("\n"),
+		activate() { fleet.handleKey("\x1b[B"); },
+		close() { fleet.dispose(); mounted.get(WIDGET_KEY)?.dispose?.(); renderWidget(ctx, []); },
+	};
+}
+
+it("does not invalidate a disposed async widget when structural coverage changes", () => {
+	const h = harness();
+	try {
+		h.mounted.get(WIDGET_KEY)!.dispose?.();
+		h.resetRequests();
+		setInlineWorkflowCoverage(h.ctx.ui, new Map([[h.job.asyncId, "structural-change"]]));
+		assert.equal(h.requests, 0);
+	} finally { h.close(); }
+});
+
+it("collapses only after the actual same-UI roster renders, and restores on deactivation/disposal", () => {
+	const h = harness();
+	try {
+		assert.match(h.asyncText(), /unique-worker/);
+		h.activate();
+		assert.match(h.asyncText(), /unique-worker/, "activation alone is not rendered coverage");
+		assert.match(h.roster(), /unique-worker/);
+		const before = h.requests;
+		assert.match(h.asyncText(), /Workflow children shown in Fleet roster/);
+		assert.doesNotMatch(h.asyncText(), /unique-worker/);
+		h.setExpanded(true);
+		assert.doesNotMatch(h.asyncText(), /unique-worker/);
+		h.fleet.handleKey("\x1b");
+		assert.ok(h.requests > before, "coverage changes invalidate the existing widget");
+		assert.match(h.asyncText(), /unique-worker/);
+		h.activate(); h.roster();
+		h.mounted.get(FLEET_STATUS_WIDGET_KEY)!.dispose?.();
+		assert.match(h.asyncText(), /unique-worker/);
+	} finally { h.close(); }
+});
+
+it("retains detail for row overflow, horizontal truncation and nested children", () => {
+	for (const kind of ["budget", "width", "nested", "overflow"] as const) {
+		const h = harness(kind === "budget" ? 1 : 20);
+		try {
+			if (kind === "nested") h.job.steps![0]!.children = [{ id: "nested", state: "running", agent: "nested-worker" }];
+			if (kind === "overflow") for (let i = 0; i < 6; i++) h.job.steps!.push({ agent: `worker-${i}`, status: "running" });
+			renderWidget(h.ctx, [...h.state.asyncJobs.values()]);
+			h.activate(); h.roster(kind === "width" ? 20 : 240);
+			assert.doesNotMatch(h.asyncText(), /Workflow children shown in Fleet roster/, kind);
+			assert.match(h.asyncText(), /unique-worker/, kind);
+		} finally { h.close(); }
+	}
+});
+
+it("revokes coverage when navigation scrolls a workflow out of the roster, or its context becomes stale", () => {
+	const h = harness(3);
+	try {
+		h.state.asyncJobs.set("later", { asyncId: "later", asyncDir: "/tmp/later", mode: "single", status: "running", startedAt: 2_000, agents: ["later-worker"] });
+		h.activate(); h.roster();
+		assert.match(h.asyncText(), /Workflow children shown in Fleet roster/);
+		h.fleet.handleKey("\x1b[B"); h.fleet.handleKey("\x1b[B"); h.roster();
+		assert.match(h.asyncText(), /unique-worker/);
+		h.fleet.handleKey("\x1b[A"); h.roster();
+		assert.match(h.asyncText(), /Workflow children shown in Fleet roster/);
+		Object.defineProperty(h.ctx, "hasUI", { get() { throw new Error("This extension ctx is stale after session replacement or reload."); }, configurable: true });
+		h.fleet.refresh();
+		assert.match(h.asyncText(), /unique-worker/);
+	} finally {
+		Object.defineProperty(h.ctx, "hasUI", { value: true, configurable: true });
+		h.close();
+	}
+});
+
+it("new step identities and materialized children revoke stale coverage within the same frame", () => {
+	const h = harness();
+	try {
+		h.activate(); h.roster();
+		assert.doesNotMatch(h.asyncText(), /unique-worker/);
+		h.job.steps!.push({ workflowKey: "lane-b", agent: "new-worker", status: "running" });
+		assert.match(h.asyncText(), /new-worker/, "in-place arrival cannot use cached covered lines");
+		h.fleet.refresh(); h.roster();
+		assert.match(h.asyncText(), /Workflow children shown in Fleet roster/);
+		const child: AsyncJobState = { asyncId: "child", asyncDir: "/tmp/child", mode: "single", status: "running", parentWorkflowRunId: h.job.asyncId, agents: ["attached-worker"] };
+		renderWidget(h.ctx, [h.job, child]);
+		assert.match(h.asyncText(), /attached-worker/);
+		assert.doesNotMatch(h.asyncText(), /Workflow children shown in Fleet roster/);
+	} finally { h.close(); }
+});
+
+function materialize(h: ReturnType<typeof harness>) {
+	h.job.steps = [];
+	const leaf = (id: string): AsyncJobState => ({ asyncId: id, asyncDir: `/tmp/${id}`, mode: "single", status: "running", parentWorkflowRunId: h.job.asyncId, agents: [`${id}-worker`] });
+	const children: [AsyncJobState, AsyncJobState] = [leaf("alpha"), leaf("beta")];
+	for (const child of children) h.state.asyncJobs.set(child.asyncId, child);
+	renderWidget(h.ctx, [...h.state.asyncJobs.values()]);
+	return children;
+}
+
+it("covers flat materialized leaf cards only after every row renders and checks child freshness", () => {
+	const h = harness(10);
+	try {
+		const [alpha, beta] = materialize(h);
+		beta.mode = "parallel"; beta.agents = ["beta-worker", "second-beta-worker"];
+		beta.steps = beta.agents.map((agent) => ({ agent, status: "running" }));
+		h.setExpanded(true);
+		assert.match(h.asyncText(), /alpha-worker/);
+		h.activate();
+		assert.match(h.asyncText(), /second-beta-worker/);
+		assert.match(h.roster(), /second-beta-worker/);
+		assert.match(h.asyncText(), /Workflow children shown in Fleet roster/);
+		assert.doesNotMatch(h.asyncText(), /alpha-worker|beta-worker/);
+		alpha.agents = ["changed-worker"];
+		assert.match(h.asyncText(), /changed-worker/);
+		h.fleet.refresh(); h.roster();
+		assert.doesNotMatch(h.asyncText(), /changed-worker/);
+		const arriving = { ...alpha, asyncId: "arriving", agents: ["arriving-worker"] };
+		h.state.asyncJobs.set(arriving.asyncId, arriving);
+		renderWidget(h.ctx, [...h.state.asyncJobs.values()]);
+		assert.match(h.asyncText(), /arriving-worker/);
+		h.fleet.refresh(); h.roster();
+		assert.doesNotMatch(h.asyncText(), /arriving-worker/);
+		h.roster(25);
+		assert.match(h.asyncText(), /arriving-worker/);
+		h.roster(); h.fleet.handleKey("\x1b");
+		assert.match(h.asyncText(), /arriving-worker/);
+	} finally { h.close(); }
+});
+
+it("restores materialized detail when child context changes without a refresh", () => {
+	const h = harness();
+	try {
+		const [alpha] = materialize(h);
+		h.activate(); h.roster();
+		assert.doesNotMatch(h.asyncText(), /alpha-worker/);
+		alpha.context = "fork";
+		assert.match(h.asyncText(), /alpha-worker/);
+		h.fleet.refresh(); h.roster();
+		assert.doesNotMatch(h.asyncText(), /alpha-worker/);
+	} finally { h.close(); }
+});
+
+it("restores chain detail when scheduling changes Fleet row membership", () => {
+	const h = harness();
+	try {
+		const [alpha, beta] = materialize(h);
+		h.state.asyncJobs.delete(beta.asyncId);
+		alpha.mode = "chain";
+		alpha.currentStep = 0;
+		alpha.steps = [
+			{ index: 0, agent: "first-worker", status: "pending" },
+			{ index: 1, agent: "second-worker", status: "pending" },
+		];
+		renderWidget(h.ctx, [h.job, alpha]);
+		setInlineWorkflowCoverage(h.ctx.ui, new Map([[h.job.asyncId, inlineWorkflowRenderKey(h.job, [alpha])]]));
+		assert.doesNotMatch(h.asyncText(), /first-worker|second-worker/);
+
+		alpha.currentStep = 1;
+		assert.match(h.asyncText(), /second-worker/, "advancing the chain revokes coverage for the old row");
+		setInlineWorkflowCoverage(h.ctx.ui, new Map([[h.job.asyncId, inlineWorkflowRenderKey(h.job, [alpha])]]));
+		assert.doesNotMatch(h.asyncText(), /first-worker|second-worker/);
+
+		alpha.activeParallelGroup = true;
+		assert.match(h.asyncText(), /first-worker/, "opening a parallel group revokes single-row chain coverage");
+	} finally { h.close(); }
+});
+
+it("keeps structural coverage and layout stable across heartbeat and token-only updates", () => {
+	const h = harness();
+	try {
+		const [alpha] = materialize(h);
+		alpha.steps = [{ agent: "alpha-worker", status: "running", tokens: { input: 10, output: 2, total: 12, window: 10 } }];
+		const initialKey = inlineWorkflowRenderKey(h.job, [alpha]);
+		h.activate(); h.roster();
+		const beforeLines = h.asyncText().split("\n").length;
+		alpha.updatedAt = 9_000;
+		alpha.lastActivityAt = 8_000;
+		alpha.turnCount = 4;
+		alpha.toolCount = 7;
+		alpha.totalTokens = { input: 30, output: 8, total: 38 };
+		alpha.steps[0]!.tokens = { input: 30, output: 8, total: 38, window: 37 };
+		assert.equal(inlineWorkflowRenderKey(h.job, [alpha]), initialKey);
+		h.fleet.refresh(); h.roster();
+		assert.equal(h.asyncText().split("\n").length, beforeLines);
+		assert.match(h.asyncText(), /Workflow children shown in Fleet roster/);
+	} finally { h.close(); }
+});
+
+it("keeps coverage across a non-structural refresh when the async widget paints before the roster", () => {
+	const h = harness();
+	const realNow = Date.now;
+	try {
+		const [alpha] = materialize(h);
+		h.activate(); h.roster();
+		assert.match(h.asyncText(), /Workflow children shown in Fleet roster/);
+		// Elapsed seconds and tokens change the roster render key every tick without changing structure.
+		Date.now = () => realNow() + 5_000;
+		alpha.totalTokens = { input: 30, output: 8, total: 38 };
+		const before = h.coverageCalls;
+		h.fleet.refresh();
+		assert.equal(h.coverageCalls, before + 1, "prepaint computes coverage synchronously");
+		// TUI order: aboveEditor async widget renders before the belowEditor roster.
+		assert.match(h.asyncText(), /Workflow children shown in Fleet roster/, "async widget must not flash its full tree");
+		assert.doesNotMatch(h.asyncText(), /alpha-worker/);
+		assert.match(h.roster(), /alpha-worker/);
+		assert.equal(h.coverageCalls, before + 1, "same-key widget paint reuses the prepaint lines");
+		alpha.steps = [{ agent: "changed-worker", status: "running" }];
+		h.fleet.refresh();
+		assert.equal(h.coverageCalls, before + 2, "structural change recomputes coverage before paint");
+		assert.match(h.roster(), /changed-worker/);
+		assert.equal(h.coverageCalls, before + 2, "structural prepaint is reused only for its matching key");
+	} finally { Date.now = realNow; h.close(); }
+});
+
+it("revokes coverage on refresh before the async widget paints when the workflow no longer fits the roster", () => {
+	const h = harness(3);
+	try {
+		h.state.asyncJobs.set("later", { asyncId: "later", asyncDir: "/tmp/later", mode: "single", status: "running", startedAt: 2_000, agents: ["later-worker"] });
+		h.activate(); h.roster();
+		assert.match(h.asyncText(), /Workflow children shown in Fleet roster/);
+		h.fleet.handleKey("\x1b[B"); h.fleet.handleKey("\x1b[B");
+		assert.match(h.asyncText(), /unique-worker/, "details must not be hidden from both surfaces for a frame");
+	} finally { h.close(); }
+});
+
+it("changes the coverage identity for membership, context, and descendant structure", () => {
+	const h = harness();
+	try {
+		const [alpha, beta] = materialize(h);
+		const key = inlineWorkflowRenderKey(h.job, [alpha, beta]);
+		alpha.context = "fork";
+		assert.notEqual(inlineWorkflowRenderKey(h.job, [alpha, beta]), key);
+		alpha.context = undefined;
+		alpha.nestedChildren = [{ id: "nested", agent: "nested-worker", state: "running" }];
+		assert.notEqual(inlineWorkflowRenderKey(h.job, [alpha, beta]), key);
+		alpha.nestedChildren = undefined;
+		assert.notEqual(inlineWorkflowRenderKey(h.job, [alpha]), key);
+	} finally { h.close(); }
+});
+
+it("revokes flat coverage on scroll, child replacement, and a new grandchild", () => {
+	const h = harness(3);
+	try {
+		const [alpha, beta] = materialize(h);
+		h.state.asyncJobs.set("later", { asyncId: "later", asyncDir: "/tmp/later", mode: "single", status: "running", agents: ["later-worker"] });
+		h.activate(); h.roster();
+		assert.doesNotMatch(h.asyncText(), /alpha-worker/);
+		for (let i = 0; i < 4; i++) h.fleet.handleKey("\x1b[B");
+		h.roster(); assert.match(h.asyncText(), /alpha-worker/);
+		h.fleet.handleKey("\x1b[A"); h.roster();
+		assert.doesNotMatch(h.asyncText(), /alpha-worker/);
+		const replacement = { ...alpha, asyncId: "replacement" };
+		h.state.asyncJobs.delete(alpha.asyncId); h.state.asyncJobs.set(replacement.asyncId, replacement);
+		renderWidget(h.ctx, [h.job, beta, replacement]);
+		assert.match(h.asyncText(), /alpha-worker/);
+		h.fleet.refresh(); h.roster();
+		assert.doesNotMatch(h.asyncText(), /alpha-worker/);
+		const grandchild = { ...beta, asyncId: "grandchild", parentWorkflowRunId: replacement.asyncId, agents: ["grandchild-worker"] };
+		renderWidget(h.ctx, [h.job, beta, replacement, grandchild]);
+		assert.match(h.asyncText(), /alpha-worker/);
+		h.setExpanded(true);
+		assert.match(h.asyncText(), /grandchild-worker/);
+	} finally { h.close(); }
+});
+
+it("retains materialized cards for incomplete, nested, uncertain and non-running groups", () => {
+	for (const kind of ["budget", "multi-row-budget", "wrapper", "grandchild", "nested", "terminal", "parent", "foreground", "chain", "external", "overflow"] as const) {
+		const h = harness(kind === "budget" ? 2 : kind === "multi-row-budget" ? 3 : 20);
+		try {
+			const [alpha, beta] = materialize(h);
+			if (kind === "multi-row-budget") { beta.mode = "parallel"; beta.agents = ["beta-worker", "second-beta-worker"]; }
+			if (kind === "wrapper") alpha.mode = "workflow";
+			if (kind === "grandchild") h.state.asyncJobs.set("grandchild", { ...beta, asyncId: "grandchild", parentWorkflowRunId: alpha.asyncId });
+			if (kind === "nested") alpha.nestedChildren = [{ id: "nested", agent: "nested-worker", state: "running" }];
+			if (kind === "terminal") alpha.status = "complete";
+			if (kind === "parent") h.job.status = "queued";
+			if (kind === "foreground") h.state.foregroundControls.set("unknown", { runId: "unknown", mode: "single", startedAt: 1000, updatedAt: 1000, parentWorkflowRunId: h.job.asyncId });
+			if (kind === "chain") { alpha.mode = "chain"; alpha.agents = ["alpha-worker", "pending-worker"]; }
+			if (kind === "external") alpha.steps = [{ agent: "alpha-worker", status: "running", runner: {
+				type: "external-job", provider: "test", options: {}, capabilities: { stop: false, steer: false, resume: false, structuredOutput: false, toolEvents: false },
+			} }];
+			if (kind === "overflow") h.job.steps = Array.from({ length: 4 }, (_, i) => ({ agent: `lane-${i}`, status: "running" }));
+			renderWidget(h.ctx, [...h.state.asyncJobs.values()]); h.setExpanded(true);
+			h.activate(); h.roster();
+			assert.doesNotMatch(h.asyncText(), /Workflow children shown in Fleet roster/, kind);
+			assert.match(h.asyncText(), kind === "overflow" ? /lane-0/ : /beta/, kind);
+		} finally { h.close(); }
+	}
+});
+
+it("restores detail for suspension, inspector transitions, UI replacement, and headless replacement", async () => {
+	let finish!: () => void;
+	const h = harness(6, () => new Promise<void>((resolve) => { finish = resolve; }));
+	try {
+		materialize(h);
+		h.job.steps = [{ agent: "unique-worker", status: "running" }];
+		h.activate(); h.roster();
+		h.state.widgetsSuspended = true; h.fleet.refresh();
+		assert.match(h.asyncText(), /unique-worker/);
+		h.state.widgetsSuspended = false; h.fleet.refresh(); h.roster();
+		assert.doesNotMatch(h.asyncText(), /unique-worker/);
+		h.fleet.handleKey("\x1b[B"); h.fleet.handleKey("\r");
+		assert.match(h.asyncText(), /unique-worker/);
+		await Promise.resolve(); finish();
+		await new Promise((resolve) => setImmediate(resolve));
+		h.roster();
+		assert.doesNotMatch(h.asyncText(), /unique-worker/);
+		h.state.fleetInspectorOpen = true; h.fleet.refresh();
+		assert.match(h.asyncText(), /unique-worker/);
+		h.state.fleetInspectorOpen = false; h.fleet.refresh(); h.roster();
+		const oldText = h.asyncText;
+		const other = harness();
+		try {
+			assert.match(other.asyncText(), /unique-worker/, "coverage cannot leak to a second UI");
+			h.fleet.setContext(other.ctx);
+			assert.match(oldText(), /unique-worker/, "old UI regains detail immediately");
+			h.fleet.setContext({ hasUI: false } as ExtensionContext);
+			assert.match(other.asyncText(), /unique-worker/);
+		} finally { other.close(); }
+	} finally { h.close(); }
+});

package/dist/extensions/pi-subagents/test/integration/intercom-result-delivery.test.ts

@@ -9,6 +9,8 @@ import { ACTIVE_ASYNC_CAPACITY_DIR, acquireActiveAsyncCapacity, activeAsyncCapac
 import { EXTERNAL_JOB_PROVIDER_REGISTRY_KEY, registerExternalJobProvider } from "../../src/api/external-job-provider.ts";
 import { serviceExternalJobBridgeRequests } from "../../src/runs/shared/external-job-bridge.ts";
 import { externalJobFollowUpRequestDigest, externalJobFollowUpRunId, externalJobPromptDigest } from "../../src/runs/shared/external-job-runner.ts";
+import { createWorktreeCleanupPlan } from "../../src/runs/shared/worktree-cleanup-plan.ts";
+import { applyReviewedCleanupPlan } from "../../src/runs/shared/worktree-cleanup-apply.ts";
 import { waitForSubagents } from "../../src/runs/background/subagent-wait.ts";
 import { createRunFanoutBudget } from "../../src/runs/shared/run-fanout-budget.ts";
 import { acquireSessionLease, sessionLeaseDir } from "../../src/runs/shared/session-lease.ts";
@@ -23,9 +25,6 @@ import {
 	tryImport,
 } from "../support/helpers.ts";
 
-/** Children with an explicit tool surface also receive the scoped capability gateway controls. */
-const CHILD_CAPABILITY_GATEWAY_TOOLS = "capability_catalog,capability_discover,capability_skill_show";
-
 interface ExecutorResult {
 	content: Array<{ text?: string }>;
 	isError?: boolean;
@@ -311,8 +310,8 @@ describe("intercom result delivery cutover", { skip: !available ? "executor not
 
 		const isolatedArgs = await readMockCallArgs(0);
 		const normalArgs = await readMockCallArgs(1);
-		assert.equal(isolatedArgs[isolatedArgs.indexOf("--tools") + 1], `read,${CHILD_CAPABILITY_GATEWAY_TOOLS}`);
-		assert.equal(normalArgs[normalArgs.indexOf("--tools") + 1], `read,contact_supervisor,${CHILD_CAPABILITY_GATEWAY_TOOLS}`);
+		assert.equal(isolatedArgs[isolatedArgs.indexOf("--tools") + 1], "read");
+		assert.equal(normalArgs[normalArgs.indexOf("--tools") + 1], "read,contact_supervisor");
 		assert.equal(events.emitted.filter((entry) => entry.channel === "subagent:result-intercom").length, 1);
 		assert.deepEqual(result.details?.workflow?.value, { isolated: "Isolated child output", normal: "Normal child output" });
 	});
@@ -538,6 +537,16 @@ describe("intercom result delivery cutover", { skip: !available ? "executor not
 		});
 		const expectedRunId = externalJobFollowUpRunId(requestDigest);
 		const continuationAsyncDir = path.join(ASYNC_DIR, expectedRunId);
+		const sourceRepo = path.join(tempDir, "retained-follow-up-repo");
+		const baseDir = path.join(tempDir, "retained-follow-up-trees");
+		const retainedTree = path.join(baseDir, path.basename(sourceRepo), "retained");
+		fs.mkdirSync(sourceRepo);
+		for (const args of [["init"], ["config", "user.name", "Fixture"], ["config", "user.email", "fixture@example.com"]]) execFileSync("git", args, { cwd: sourceRepo, stdio: "ignore" });
+		fs.writeFileSync(path.join(sourceRepo, "base.txt"), "base");
+		execFileSync("git", ["add", "base.txt"], { cwd: sourceRepo }); execFileSync("git", ["commit", "-m", "base"], { cwd: sourceRepo, stdio: "ignore" });
+		execFileSync("git", ["worktree", "add", "-b", "fixture-retained", retainedTree], { cwd: sourceRepo, stdio: "ignore" });
+		const recordedBaseDir = fs.realpathSync.native(path.dirname(retainedTree));
+		const baseCommit = execFileSync("git", ["rev-parse", "HEAD"], { cwd: sourceRepo, encoding: "utf-8" }).trim();
 		let followUps = 0;
 		registerExternalJobProvider({
 			name: "surf-oracle",
@@ -571,11 +580,24 @@ describe("intercom result delivery cutover", { skip: !available ? "executor not
 					externalJob: { provider: "surf-oracle", providerJobId: "job-parent", promptDigest: externalJobPromptDigest("original prompt"), options: { tier: "pro" }, state: "completed" },
 				}],
 			}, null, 2), "utf-8");
+			const handoffPath = path.join(sourceAsyncDir, "handoff.json");
+			fs.writeFileSync(handoffPath, JSON.stringify({ version: 1, runId: sourceRunId, source: "async", mode: "single", cwd: sourceRepo, createdAt: 1, updatedAt: 1, groups: [{ stepIndex: 0, repoRoot: sourceRepo, baseCommit,
+				children: [{ index: 0, taskIndex: 0, agent: "gpt-pro", status: "completed", summary: "done", patch: { path: path.join(sourceAsyncDir, "work.patch"), branch: "fixture-retained", changed: false } }],
+				cleanup: { state: "partial", pruned: false, tasks: [{ index: 0, path: retainedTree, branch: "fixture-retained", recordedBaseDir, preserved: true, worktreeRemoved: false, branchRemoved: false }] },
+			}] }));
+			const reviewed = createWorktreeCleanupPlan({ repo: sourceRepo, handoffPath, worktreeBaseDir: baseDir });
+			assert.equal(reviewed.plan.entries[0]?.decision, "remove");
+
 			const { executor } = makeExecutor({ agents: [makeAgent("gpt-pro", { runner: { type: "external-job", provider: "surf-oracle", options: { tier: "pro" } } })] });
 
 			const first = await executor.execute("resume-external-job-first", { action: "resume", id: sourceRunId, message: followUpMessage }, new AbortController().signal, undefined, makeMinimalCtx(tempDir));
 			assert.equal(first.isError, undefined, first.content[0]?.text ?? "follow-up failed");
 			assert.equal(first.details?.asyncId, expectedRunId);
+			const protectedManifest = JSON.parse(fs.readFileSync(handoffPath, "utf-8"));
+			assert.match(protectedManifest.groups[0].cleanup.tasks[0].reason, /retained child resume/);
+			const cleanup = await applyReviewedCleanupPlan({ repo: sourceRepo, planId: reviewed.plan.planId, authorized: true });
+			assert.equal(cleanup.receipt.entries[0]?.state, "kept");
+			assert.ok(fs.existsSync(retainedTree));
 
 			const duplicate = await executor.execute("resume-external-job-duplicate", { action: "resume", id: sourceRunId, message: followUpMessage }, new AbortController().signal, undefined, makeMinimalCtx(tempDir));
 			assert.equal(duplicate.isError, undefined, duplicate.content[0]?.text ?? "duplicate failed");
@@ -600,6 +622,7 @@ describe("intercom result delivery cutover", { skip: !available ? "executor not
 			assert.equal(status.steps?.[0]?.externalJob?.requestDigest, requestDigest);
 			assert.equal(status.steps?.[0]?.externalJob?.providerJobId, "job-child");
 		} finally {
+			try { execFileSync("git", ["-C", sourceRepo, "worktree", "remove", "--force", retainedTree], { stdio: "ignore" }); } catch {}
 			fs.rmSync(sourceAsyncDir, { recursive: true, force: true, maxRetries: 5, retryDelay: 20 });
 			fs.rmSync(continuationAsyncDir, { recursive: true, force: true, maxRetries: 5, retryDelay: 20 });
 			fs.rmSync(path.join(RESULTS_DIR, `${expectedRunId}.json`), { force: true });
@@ -777,6 +800,82 @@ describe("intercom result delivery cutover", { skip: !available ? "executor not
 		}
 	});
 
+	it("resume action rejects malformed explicit output schemas before lookup", async () => {
+		for (const [index, params] of [
+			{ message: "Continue", outputSchema: true },
+			{ message: "Continue", outputSchema: null },
+			{ chain: [{ agent: "worker", task: "Continue", outputSchema: [] }] },
+		].entries()) {
+			const { executor, events } = makeExecutor();
+			const result = await executor.execute(
+				`resume-invalid-schema-${index}`,
+				{ action: "resume", id: "missing-source-run", ...params },
+				new AbortController().signal,
+				undefined,
+				makeMinimalCtx(tempDir),
+			);
+			assert.equal(result.isError, true);
+			assert.match(result.content[0]?.text ?? "", /Cannot resume: outputSchema must be a JSON Schema object/);
+			assert.equal(events.emitted.some((entry) => entry.channel === SUBAGENT_ASYNC_STARTED_EVENT), false);
+		}
+	});
+
+	it("rejects either false-schema report polarity before acquiring resume capacity", async () => {
+		const schema = { type: "object", required: ["ok"], properties: { ok: { type: "boolean" } } };
+		for (const report of ["on", "off"] as const) {
+			for (const polarity of ["retained-false", "explicit-false"] as const) {
+				const parentSessionId = `session-resume-${polarity}-${report}-${Date.now()}`;
+				try {
+					const { executor, events } = makeExecutor({ maxActiveAsyncRunsPerSession: 1 });
+					const ctx = makeMinimalCtx(tempDir);
+					ctx.sessionManager.getSessionId = () => parentSessionId;
+					if (polarity === "retained-false") {
+						mockPi.onCall({ output: "unstructured result" });
+					} else {
+						const structuredEvents = [
+							{ type: "tool_execution_start", toolName: "structured_output", args: { value: { ok: true } } },
+							{ type: "tool_result_end", message: { role: "toolResult", toolName: "structured_output", content: [{ type: "text", text: "Structured output captured." }] } },
+							{ type: "tool_execution_end", toolName: "structured_output" },
+						];
+						mockPi.onCall({
+							stdoutRaw: structuredEvents.map((entry) => JSON.stringify(entry)).join("\n") + "\n",
+							structuredOutputCapture: { ok: true },
+						});
+					}
+					const first = await executor.execute(
+						`resume-${polarity}-${report}-source`,
+						polarity === "retained-false"
+							? { agent: "worker", task: "Return prose", async: false, outputSchema: false, acceptance: false }
+							: { agent: "worker", task: "Return data", async: false, outputSchema: schema, acceptance: { level: "checked", report } },
+						new AbortController().signal,
+						undefined,
+						ctx,
+					);
+					if (polarity === "retained-false") assert.equal(first.isError, undefined, first.content[0]?.text ?? "source run failed");
+					assert.ok(first.details.runId);
+					assert.deepEqual(getActiveAsyncCapacitySnapshot(parentSessionId, 1), { used: 0, limit: 1 });
+					const result = await executor.execute(
+						`resume-${polarity}-${report}`,
+						polarity === "retained-false"
+							? { action: "resume", id: first.details.runId, message: "Continue", acceptance: { level: "checked", report } }
+							: { action: "resume", id: first.details.runId, message: "Continue", outputSchema: false },
+						new AbortController().signal,
+						undefined,
+						ctx,
+					);
+					assert.equal(result.isError, true);
+					assert.match(result.content[0]?.text ?? "", /Cannot resume: acceptance\.report requires outputSchema/);
+					assert.deepEqual(getActiveAsyncCapacitySnapshot(parentSessionId, 1), { used: 0, limit: 1 });
+					assert.equal(mockPi.callCount(), 1);
+					assert.equal(events.emitted.some((entry) => entry.channel === SUBAGENT_ASYNC_STARTED_EVENT), false);
+				} finally {
+					fs.rmSync(path.join(ACTIVE_ASYNC_CAPACITY_DIR, activeAsyncCapacitySessionKey(parentSessionId)), { recursive: true, force: true });
+					mockPi.reset();
+				}
+			}
+		}
+	});
+
 	it("resume action can attach a live async child as the first step of a new chain", async () => {
 		const sourceRunId = `resume-chain-root-${Date.now()}`;
 		const sourceAsyncDir = path.join(ASYNC_DIR, sourceRunId);
@@ -851,6 +950,7 @@ describe("intercom result delivery cutover", { skip: !available ? "executor not
 		const sourceRunId = `resume-chain-complete-root-${Date.now()}`;
 		const sourceAsyncDir = path.join(ASYNC_DIR, sourceRunId);
 		const sourceResultPath = path.join(RESULTS_DIR, `${sourceRunId}.json`);
+		const parentSessionId = "session-123";
 		try {
 			fs.mkdirSync(sourceAsyncDir, { recursive: true });
 			fs.mkdirSync(RESULTS_DIR, { recursive: true });
@@ -874,28 +974,49 @@ describe("intercom result delivery cutover", { skip: !available ? "executor not
 				summary: "completed root output",
 				results: [{ agent: "worker", output: "completed root output", success: true }],
 			}, null, 2), "utf-8");
-			const { executor } = makeExecutor({ agents: [makeAgent("worker"), makeAgent("reviewer")] });
+			const reviewer = { ...makeAgent("reviewer"), outputSchema: { type: "object", required: ["ok"], properties: { ok: { type: "boolean" } } } };
+			const { executor, events } = makeExecutor({ agents: [makeAgent("worker"), reviewer], maxActiveAsyncRunsPerSession: 1 });
+			const ctx = makeMinimalCtx(tempDir);
+			ctx.sessionManager.getSessionId = () => parentSessionId;
 
 			const reviveOnly = await executor.execute(
 				"resume-chain-complete-root-revive-only",
 				{ action: "resume", id: sourceRunId, message: "Follow up" },
 				new AbortController().signal,
 				undefined,
-				makeMinimalCtx(tempDir),
+				ctx,
 			);
 			assert.equal(reviveOnly.isError, true);
 			assert.match(reviveOnly.content[0]?.text ?? "", /does not have a persisted session file/);
 
+			for (const [name, params] of [
+				["top-level", { outputSchema: false, acceptance: { level: "checked", report: "on" }, chain: [{ agent: "reviewer", task: "Review" }] }],
+				["child", { chain: [{ agent: "reviewer", task: "Review", outputSchema: false, acceptance: { level: "checked", report: "off" } }] }],
+			] as const) {
+				const rejected = await executor.execute(
+					`resume-chain-invalid-${name}`,
+					{ action: "resume", id: sourceRunId, ...params },
+					new AbortController().signal,
+					undefined,
+					ctx,
+				);
+				assert.equal(rejected.isError, true);
+				assert.match(rejected.content[0]?.text ?? "", /Cannot resume: .*acceptance\.report requires outputSchema/);
+				assert.deepEqual(getActiveAsyncCapacitySnapshot(parentSessionId, 1), { used: 0, limit: 1 });
+				assert.equal(mockPi.callCount(), 0);
+				assert.equal(events.emitted.some((entry) => entry.channel === SUBAGENT_ASYNC_STARTED_EVENT), false);
+			}
+
 			const attached = await executor.execute(
 				"resume-chain-complete-root",
 				{
 					action: "resume",
 					id: sourceRunId,
-					chain: [{ agent: "reviewer", task: "Review this completed root result: {previous}" }],
+					chain: [{ agent: "reviewer", task: "Review this completed root result: {previous}", acceptance: { level: "checked", report: "on" } }],
 				},
 				new AbortController().signal,
 				undefined,
-				makeMinimalCtx(tempDir),
+				ctx,
 			);
 
 			assert.equal(attached.isError, undefined);
@@ -906,6 +1027,7 @@ describe("intercom result delivery cutover", { skip: !available ? "executor not
 		} finally {
 			fs.rmSync(sourceAsyncDir, { recursive: true, force: true });
 			fs.rmSync(sourceResultPath, { force: true });
+			fs.rmSync(path.join(ACTIVE_ASYNC_CAPACITY_DIR, activeAsyncCapacitySessionKey(parentSessionId)), { recursive: true, force: true });
 		}
 	});
 
@@ -1017,6 +1139,69 @@ describe("intercom result delivery cutover", { skip: !available ? "executor not
 		}
 	});
 
+	it("resume action on a failed workflow child makes the revival that key's latest run", async () => {
+		mockPi.onCall({ output: "revived memory report" });
+		const suffix = `${Date.now()}-${Math.random().toString(16).slice(2)}`;
+		const workflowRunId = `revive-workflow-${suffix}`;
+		const childRunId = `revive-workflow-child-${suffix}`;
+		const workflowDir = path.join(ASYNC_DIR, workflowRunId);
+		const childDir = path.join(ASYNC_DIR, childRunId);
+		const sessionFile = path.join(tempDir, "memory-child.jsonl");
+		const cleanup = [workflowDir, childDir];
+		try {
+			fs.mkdirSync(workflowDir, { recursive: true });
+			fs.mkdirSync(childDir, { recursive: true });
+			fs.writeFileSync(sessionFile, "", "utf-8");
+			fs.writeFileSync(path.join(workflowDir, "status.json"), JSON.stringify({
+				runId: workflowRunId, sessionId: "session-123", mode: "workflow", state: "complete", startedAt: 100, endedAt: 300, cwd: tempDir,
+				steps: [{ agent: "worker", workflowKey: "memory", runId: childRunId, status: "failed", error: "429 rate limit" }],
+			}), "utf-8");
+			fs.writeFileSync(path.join(workflowDir, "workflow-receipt.json"), JSON.stringify({
+				version: 1, workflowRunId, state: "complete", createdAt: 300,
+				entries: { memory: { key: "memory", agent: "worker", latestRunId: childRunId, continuation: { runIds: [childRunId] }, resumability: { state: "resumable" } } },
+			}), "utf-8");
+			fs.writeFileSync(path.join(childDir, "status.json"), JSON.stringify({
+				runId: childRunId, sessionId: "session-123", mode: "single", state: "failed", startedAt: 100, endedAt: 200, cwd: tempDir,
+				parentWorkflowRunId: workflowRunId, workflowKey: "memory", sessionFile,
+				steps: [{ agent: "worker", status: "failed", sessionFile, error: "429 rate limit" }],
+			}), "utf-8");
+			writeRecoveryDescriptor(childDir, childRunId);
+			const { executor } = makeExecutor();
+
+			const revived = await executor.execute("revive-workflow-child", { action: "resume", id: childRunId, message: "Retry after the rate limit." }, new AbortController().signal, undefined, makeMinimalCtx(tempDir));
+			assert.equal(revived.isError, undefined, revived.content[0]?.text);
+			const revivedId = revived.details?.asyncId;
+			assert.ok(revivedId, "expected revived async id");
+			cleanup.push(path.join(ASYNC_DIR, revivedId), path.join(RESULTS_DIR, `${revivedId}.json`));
+			await waitForFile(path.join(RESULTS_DIR, `${revivedId}.json`));
+			const revivedStatusPath = path.join(ASYNC_DIR, revivedId, "status.json");
+			await waitForStatus(revivedStatusPath, (candidate) => candidate.state === "complete");
+
+			const status = await executor.execute("workflow-status", { action: "status", id: workflowRunId }, new AbortController().signal, undefined, makeMinimalCtx(tempDir));
+			assert.match(status.content[0]?.text ?? "", new RegExp(`Child run: ${childRunId}\\n {2}Revived → ${revivedId}: completed`));
+
+			mockPi.onCall({ output: "follow-up summary" });
+			const continued = await executor.execute(
+				"continue-workflow-key",
+				{ async: false, workflowScript: `return runs.run("memory-followup", { resume: { workflowRunId: ${JSON.stringify(workflowRunId)}, key: "memory", latest: true }, task: "Summarize the report.", output: false });` },
+				new AbortController().signal,
+				undefined,
+				makeMinimalCtx(tempDir),
+			);
+			assert.equal(continued.isError, undefined, continued.content[0]?.text);
+			const child = continued.details!.workflow!.value as { runId: string; continuation: { runIds: string[] } };
+			cleanup.push(path.join(ASYNC_DIR, child.runId), path.join(RESULTS_DIR, `${child.runId}.json`));
+			assert.deepEqual(child.continuation.runIds, [childRunId, revivedId, child.runId]);
+
+			const revivedStatus = JSON.parse(fs.readFileSync(revivedStatusPath, "utf-8"));
+			fs.writeFileSync(revivedStatusPath, JSON.stringify({ ...revivedStatus, state: "running", endedAt: undefined }), "utf-8");
+			const runningStatus = await executor.execute("workflow-status-running", { action: "status", id: workflowRunId }, new AbortController().signal, undefined, makeMinimalCtx(tempDir));
+			assert.match(runningStatus.content[0]?.text ?? "", new RegExp(`Revived → ${revivedId}: running`));
+		} finally {
+			for (const target of cleanup) fs.rmSync(target, { recursive: true, force: true });
+		}
+	});
+
 	it("resume action runs retained children in a managed worktree when requested", async () => {
 		execFileSync("git", ["init"], { cwd: tempDir, stdio: "ignore" });
 		execFileSync("git", ["config", "user.email", "test@example.com"], { cwd: tempDir });
@@ -1109,7 +1294,7 @@ describe("intercom result delivery cutover", { skip: !available ? "executor not
 			const args = await readMockCallArgs(0);
 			assert.equal(args[args.indexOf("--session") + 1], sessionFile);
 			assert.equal(args[args.indexOf("--model") + 1], "anthropic/claude-sonnet-4:high");
-			assert.equal(args[args.indexOf("--tools") + 1], `read,${CHILD_CAPABILITY_GATEWAY_TOOLS}`);
+			assert.equal(args[args.indexOf("--tools") + 1], "read");
 			assert.equal(args.includes("--system-prompt"), true);
 			assert.equal(args.includes("--append-system-prompt"), false);
 			await waitForFile(path.join(RESULTS_DIR, `${revivedId}.json`));