@os-eco/overstory-cli 0.10.3 → 0.11.0

package/src/commands/log.test.ts

@@ -1299,6 +1299,81 @@ describe("logCommand", () => {
 		expect(mail?.body).toContain("10 tool calls");
 		expect(mail?.body).toContain("pattern"); // At least 1 pattern insight
 	});
+
+	test("threads outcomeStatus into per-domain reference and per-insight records", async () => {
+		const learnResult: MulchLearnResult = {
+			success: true,
+			command: "mulch learn",
+			changedFiles: ["src/foo.ts"],
+			suggestedDomains: ["typescript"],
+			unmatchedFiles: [],
+		};
+		const { client, recordCalls } = createFakeMulchClient(learnResult);
+		const mailDbPath = join(tempDir, ".overstory", "auto-record-outcome.db");
+
+		// Seed events so analyzer emits at least one insight (10+ tool calls).
+		const eventsDbPath = join(tempDir, ".overstory", "events.db");
+		const eventStore = createEventStore(eventsDbPath);
+		const sessionStartedAt = new Date(Date.now() - 60_000).toISOString();
+		for (let i = 0; i < 10; i++) {
+			eventStore.insert({
+				runId: null,
+				agentName: "outcome-agent",
+				sessionId: "sess-outcome",
+				eventType: "tool_start",
+				toolName: "Read",
+				toolArgs: JSON.stringify({ file_path: `/src/file${i}.ts` }),
+				toolDurationMs: null,
+				level: "info",
+				data: JSON.stringify({ summary: `read: /src/file${i}.ts` }),
+			});
+		}
+		eventStore.close();
+
+		await autoRecordExpertise({
+			mulchClient: client,
+			agentName: "outcome-agent",
+			capability: "builder",
+			taskId: "bead-outcome",
+			mailDbPath,
+			parentAgent: "parent-agent",
+			projectRoot: tempDir,
+			sessionStartedAt,
+			outcomeStatus: "partial",
+		});
+
+		expect(recordCalls.length).toBeGreaterThanOrEqual(2);
+		for (const call of recordCalls) {
+			expect(call.options.outcomeStatus).toBe("partial");
+			expect(call.options.outcomeAgent).toBe("outcome-agent");
+		}
+	});
+
+	test("omits outcomeStatus when caller does not supply one", async () => {
+		const learnResult: MulchLearnResult = {
+			success: true,
+			command: "mulch learn",
+			changedFiles: ["src/foo.ts"],
+			suggestedDomains: ["typescript"],
+			unmatchedFiles: [],
+		};
+		const { client, recordCalls } = createFakeMulchClient(learnResult);
+		const mailDbPath = join(tempDir, ".overstory", "auto-record-no-outcome.db");
+
+		await autoRecordExpertise({
+			mulchClient: client,
+			agentName: "no-outcome-agent",
+			capability: "builder",
+			taskId: null,
+			mailDbPath,
+			parentAgent: null,
+			projectRoot: tempDir,
+			sessionStartedAt: new Date().toISOString(),
+		});
+
+		expect(recordCalls).toHaveLength(1);
+		expect(recordCalls[0]?.options.outcomeStatus).toBeUndefined();
+	});
 });
 
 /**
@@ -1779,4 +1854,60 @@ describe("appendOutcomeToAppliedRecords", () => {
 		});
 		expect(count).toBe(0);
 	});
+
+	test("uses supplied outcomeStatus when provided", async () => {
+		const agentDir = join(tempDir, ".overstory", "agents", "test-agent");
+		await mkdir(agentDir, { recursive: true });
+		await Bun.write(
+			join(agentDir, "applied-records.json"),
+			JSON.stringify({
+				taskId: "bead-outcome",
+				agentName: "test-agent",
+				capability: "builder",
+				records: [{ id: "mx-aaa111", domain: "agents" }],
+			}),
+		);
+
+		const { client, appendOutcomeCalls } = makeOutcomeClient();
+		await appendOutcomeToAppliedRecords({
+			mulchClient: client,
+			agentName: "test-agent",
+			capability: "builder",
+			taskId: "bead-outcome",
+			projectRoot: tempDir,
+			outcomeStatus: "failure",
+		});
+
+		expect(appendOutcomeCalls).toHaveLength(1);
+		expect(appendOutcomeCalls[0]?.outcome).toMatchObject({ status: "failure" });
+		expect(appendOutcomeCalls[0]?.outcome.notes).toContain("Quality gates: failure");
+	});
+
+	test("falls back to 'success' when outcomeStatus is undefined (backward compat)", async () => {
+		const agentDir = join(tempDir, ".overstory", "agents", "test-agent");
+		await mkdir(agentDir, { recursive: true });
+		await Bun.write(
+			join(agentDir, "applied-records.json"),
+			JSON.stringify({
+				taskId: "bead-default",
+				agentName: "test-agent",
+				capability: "builder",
+				records: [{ id: "mx-bbb222", domain: "agents" }],
+			}),
+		);
+
+		const { client, appendOutcomeCalls } = makeOutcomeClient();
+		await appendOutcomeToAppliedRecords({
+			mulchClient: client,
+			agentName: "test-agent",
+			capability: "builder",
+			taskId: "bead-default",
+			projectRoot: tempDir,
+		});
+
+		expect(appendOutcomeCalls).toHaveLength(1);
+		expect(appendOutcomeCalls[0]?.outcome.status).toBe("success");
+		// No "Quality gates:" annotation when caller didn't provide outcomeStatus
+		expect(appendOutcomeCalls[0]?.outcome.notes).not.toContain("Quality gates:");
+	});
 });

package/src/commands/log.ts

@@ -19,6 +19,7 @@ import { ValidationError } from "../errors.ts";
 import { createEventStore } from "../events/store.ts";
 import { filterToolArgs } from "../events/tool-filter.ts";
 import { analyzeSessionInsights } from "../insights/analyzer.ts";
+import { hasWorkToVerify, runQualityGates } from "../insights/quality-gates.ts";
 import { createLogger } from "../logging/logger.ts";
 import { createMailClient } from "../mail/client.ts";
 import { createMailStore } from "../mail/store.ts";
@@ -379,6 +380,7 @@ export async function autoRecordExpertise(params: {
 	parentAgent: string | null;
 	projectRoot: string;
 	sessionStartedAt: string;
+	outcomeStatus?: "success" | "partial" | "failure";
 }): Promise<string[]> {
 	const learnResult = await params.mulchClient.learn({ since: "HEAD~1" });
 	if (learnResult.suggestedDomains.length === 0) {
@@ -395,6 +397,8 @@ export async function autoRecordExpertise(params: {
 				description: `${params.capability} agent ${params.agentName} completed work in this domain. Files: ${filesList}`,
 				tags: ["auto-session-end", params.capability],
 				evidenceBead: params.taskId ?? undefined,
+				outcomeStatus: params.outcomeStatus,
+				outcomeAgent: params.agentName,
 			});
 			recordedDomains.push(domain);
 		} catch {
@@ -434,6 +438,8 @@ export async function autoRecordExpertise(params: {
 					description: insight.description,
 					tags: insight.tags,
 					evidenceBead: params.taskId ?? undefined,
+					outcomeStatus: params.outcomeStatus,
+					outcomeAgent: params.agentName,
 				});
 				if (!recordedDomains.includes(insight.domain)) {
 					recordedDomains.push(insight.domain);
@@ -500,6 +506,7 @@ export async function appendOutcomeToAppliedRecords(params: {
 	capability: string;
 	taskId: string | null;
 	projectRoot: string;
+	outcomeStatus?: "success" | "partial" | "failure";
 }): Promise<number> {
 	const appliedRecordsPath = join(
 		params.projectRoot,
@@ -522,10 +529,12 @@ export async function appendOutcomeToAppliedRecords(params: {
 	if (!records || records.length === 0) return 0;
 
 	const taskSuffix = params.taskId ? ` for task ${params.taskId}` : "";
+	const status: "success" | "partial" | "failure" = params.outcomeStatus ?? "success";
+	const gateNote = params.outcomeStatus ? ` Quality gates: ${params.outcomeStatus}.` : "";
 	const outcome = {
-		status: "success" as const,
+		status,
 		agent: params.agentName,
-		notes: `Applied by ${params.capability} agent ${params.agentName}${taskSuffix}. Session completed.`,
+		notes: `Applied by ${params.capability} agent ${params.agentName}${taskSuffix}. Session completed.${gateNote}`,
 	};
 
 	let appended = 0;
@@ -793,6 +802,30 @@ async function runLog(opts: {
 						// Non-fatal: metrics recording should not break session-end handling
 					}
 
+					// Resolve outcome status from quality-gate results, threaded into
+					// every session-end mulch record write so confirmation scoring
+					// reflects whether tests/lint/typecheck actually passed.
+					let outcomeStatus: "success" | "partial" | "failure" | undefined;
+					if (!isStopHookPersistentCapability(agentSession.capability)) {
+						try {
+							let baseRef = "main";
+							const baseBranchPath = join(config.project.root, ".overstory", "session-branch.txt");
+							const baseFile = Bun.file(baseBranchPath);
+							if (await baseFile.exists()) {
+								const txt = (await baseFile.text()).trim();
+								if (txt.length > 0) baseRef = txt;
+							}
+							const hasWork = await hasWorkToVerify(agentSession.worktreePath, baseRef);
+							if (hasWork) {
+								const gates = config.project.qualityGates ?? [];
+								const outcome = await runQualityGates(gates, agentSession.worktreePath);
+								if (outcome) outcomeStatus = outcome.status;
+							}
+						} catch {
+							// Non-fatal: outcome status is optional
+						}
+					}
+
 					// Auto-record expertise via mulch learn + record (post-session).
 					// Skip persistent agents whose Stop hook fires every turn.
 					if (!isStopHookPersistentCapability(agentSession.capability)) {
@@ -808,6 +841,7 @@ async function runLog(opts: {
 								parentAgent: agentSession.parentAgent,
 								projectRoot: config.project.root,
 								sessionStartedAt: agentSession.startedAt,
+								outcomeStatus,
 							});
 						} catch {
 							// Non-fatal: mulch learn/record should not break session-end handling
@@ -825,6 +859,7 @@ async function runLog(opts: {
 								capability: agentSession.capability,
 								taskId,
 								projectRoot: config.project.root,
+								outcomeStatus,
 							});
 						} catch {
 							// Non-fatal

package/src/commands/merge.test.ts

@@ -708,6 +708,124 @@ merge:
 		});
 	});
 
+	describe("--dry-run conflict prediction", () => {
+		test("--dry-run --json includes prediction.wouldRequireAgent for contentful-canonical conflict", async () => {
+			await setupProject(repoDir, defaultBranch);
+
+			// Build a real contentful-canonical conflict on src/shared.ts.
+			await commitFile(repoDir, "src/shared.ts", "shared base\n");
+			const branchName = "overstory/builder/bead-predict-1";
+			await runGitInDir(repoDir, ["checkout", "-b", branchName]);
+			await commitFile(repoDir, "src/shared.ts", "feature side\n");
+			await runGitInDir(repoDir, ["checkout", defaultBranch]);
+			await commitFile(repoDir, "src/shared.ts", "main side\n");
+
+			let output = "";
+			const originalWrite = process.stdout.write.bind(process.stdout);
+			process.stdout.write = (chunk: unknown): boolean => {
+				output += String(chunk);
+				return true;
+			};
+
+			try {
+				await mergeCommand({ branch: branchName, dryRun: true, json: true });
+			} finally {
+				process.stdout.write = originalWrite;
+			}
+
+			const parsed = JSON.parse(output);
+			expect(parsed.prediction).toBeDefined();
+			expect(parsed.prediction.wouldRequireAgent).toBe(true);
+			expect(parsed.prediction.predictedTier).toBe("ai-resolve");
+			expect(parsed.prediction.conflictFiles).toContain("src/shared.ts");
+			expect(typeof parsed.prediction.reason).toBe("string");
+
+			// Existing dry-run fields must still be present.
+			expect(parsed.branchName).toBe(branchName);
+			expect(parsed.status).toBe("pending");
+		});
+
+		test("--dry-run --json reports clean-merge prediction for non-conflicting branch", async () => {
+			await setupProject(repoDir, defaultBranch);
+			const branchName = "overstory/builder/bead-predict-2";
+			await createCleanFeatureBranch(repoDir, branchName);
+
+			let output = "";
+			const originalWrite = process.stdout.write.bind(process.stdout);
+			process.stdout.write = (chunk: unknown): boolean => {
+				output += String(chunk);
+				return true;
+			};
+
+			try {
+				await mergeCommand({ branch: branchName, dryRun: true, json: true });
+			} finally {
+				process.stdout.write = originalWrite;
+			}
+
+			const parsed = JSON.parse(output);
+			expect(parsed.prediction.predictedTier).toBe("clean-merge");
+			expect(parsed.prediction.wouldRequireAgent).toBe(false);
+			expect(parsed.prediction.conflictFiles).toEqual([]);
+		});
+
+		test("--all --dry-run --json attaches prediction to each entry", async () => {
+			await setupProject(repoDir, defaultBranch);
+			const cleanBranch = "overstory/builder/bead-predict-all-clean";
+			await createCleanFeatureBranch(repoDir, cleanBranch);
+
+			// Add a contentful-canonical conflict branch.
+			await commitFile(repoDir, "src/shared.ts", "shared base\n");
+			const conflictBranch = "overstory/builder/bead-predict-all-conflict";
+			await runGitInDir(repoDir, ["checkout", "-b", conflictBranch]);
+			await commitFile(repoDir, "src/shared.ts", "feature side\n");
+			await runGitInDir(repoDir, ["checkout", defaultBranch]);
+			await commitFile(repoDir, "src/shared.ts", "main side\n");
+
+			const queuePath = join(repoDir, ".overstory", "merge-queue.db");
+			const queue = createMergeQueue(queuePath);
+			queue.enqueue({
+				branchName: cleanBranch,
+				taskId: "bead-predict-all-clean",
+				agentName: "builder",
+				filesModified: [`src/${cleanBranch}.ts`],
+			});
+			queue.enqueue({
+				branchName: conflictBranch,
+				taskId: "bead-predict-all-conflict",
+				agentName: "builder",
+				filesModified: ["src/shared.ts"],
+			});
+			queue.close();
+
+			let output = "";
+			const originalWrite = process.stdout.write.bind(process.stdout);
+			process.stdout.write = (chunk: unknown): boolean => {
+				output += String(chunk);
+				return true;
+			};
+
+			try {
+				await mergeCommand({ all: true, dryRun: true, json: true });
+			} finally {
+				process.stdout.write = originalWrite;
+			}
+
+			const parsed = JSON.parse(output);
+			expect(parsed.entries).toHaveLength(2);
+			const cleanEntry = parsed.entries.find(
+				(e: { branchName: string }) => e.branchName === cleanBranch,
+			);
+			const conflictEntry = parsed.entries.find(
+				(e: { branchName: string }) => e.branchName === conflictBranch,
+			);
+			expect(cleanEntry.prediction.predictedTier).toBe("clean-merge");
+			expect(cleanEntry.prediction.wouldRequireAgent).toBe(false);
+			expect(conflictEntry.prediction.predictedTier).toBe("ai-resolve");
+			expect(conflictEntry.prediction.wouldRequireAgent).toBe(true);
+		});
+	});
+
 	describe("conflict handling", () => {
 		test("content conflict auto-resolves: same file modified on both branches, verify incoming content wins", async () => {
 			await setupProject(repoDir, defaultBranch);

package/src/commands/merge.ts

@@ -17,10 +17,11 @@ import { MergeError, ValidationError } from "../errors.ts";
 import { jsonOutput } from "../json.ts";
 import { accent, printHint } from "../logging/color.ts";
 import { acquireMergeLock } from "../merge/lock.ts";
+import { predictConflicts } from "../merge/predict.ts";
 import { createMergeQueue } from "../merge/queue.ts";
 import { createMergeResolver } from "../merge/resolver.ts";
 import { createMulchClient } from "../mulch/client.ts";
-import type { MergeEntry, MergeResult } from "../types.ts";
+import type { ConflictPrediction, MergeEntry, MergeResult } from "../types.ts";
 
 export interface MergeOptions {
 	branch?: string;
@@ -109,7 +110,7 @@ function formatResult(result: MergeResult): string {
 }
 
 /** Format a dry-run report for a merge entry. */
-function formatDryRun(entry: MergeEntry): string {
+function formatDryRun(entry: MergeEntry, prediction?: ConflictPrediction): string {
 	const lines: string[] = [
 		`[dry-run] Branch: ${accent(entry.branchName)}`,
 		`   Agent: ${accent(entry.agentName)} | Task: ${accent(entry.taskId)}`,
@@ -123,9 +124,41 @@ function formatDryRun(entry: MergeEntry): string {
 		}
 	}
 
+	if (prediction) {
+		const agentSuffix = prediction.wouldRequireAgent ? " (would require merger agent)" : "";
+		lines.push(`   Prediction: ${prediction.predictedTier}${agentSuffix} — ${prediction.reason}`);
+		if (prediction.conflictFiles.length > 0) {
+			lines.push(`   Conflict files: ${prediction.conflictFiles.join(", ")}`);
+		}
+	}
+
 	return lines.join("\n");
 }
 
+/**
+ * Predict the merge tier for a single entry, swallowing errors into a
+ * deterministic `ai-resolve` envelope so that `--all --dry-run` can keep
+ * going if one branch's prediction blows up.
+ */
+async function safePredictForEntry(
+	entry: MergeEntry,
+	canonicalBranch: string,
+	repoRoot: string,
+	mulchClient: ReturnType<typeof createMulchClient>,
+): Promise<ConflictPrediction> {
+	try {
+		return await predictConflicts(entry, canonicalBranch, repoRoot, mulchClient);
+	} catch (err) {
+		const msg = err instanceof Error ? err.message : String(err);
+		return {
+			predictedTier: "ai-resolve",
+			conflictFiles: [],
+			wouldRequireAgent: true,
+			reason: `prediction-failed: ${msg}`,
+		};
+	}
+}
+
 /**
  * Entry point for `ov merge [flags]`.
  *
@@ -238,10 +271,13 @@ async function handleBranch(
 	}
 
 	if (dryRun) {
+		const mulchClient = createMulchClient(config.project.root);
+		const prediction = await safePredictForEntry(entry, canonicalBranch, repoRoot, mulchClient);
+
 		if (json) {
-			jsonOutput("merge", { ...entry });
+			jsonOutput("merge", { ...entry, prediction });
 		} else {
-			process.stdout.write(`${formatDryRun(entry)}\n`);
+			process.stdout.write(`${formatDryRun(entry, prediction)}\n`);
 		}
 		return;
 	}
@@ -293,14 +329,21 @@ async function handleAll(
 	}
 
 	if (dryRun) {
+		const mulchClient = createMulchClient(config.project.root);
+		const enrichedEntries: Array<MergeEntry & { prediction: ConflictPrediction }> = [];
+		for (const entry of pendingEntries) {
+			const prediction = await safePredictForEntry(entry, canonicalBranch, repoRoot, mulchClient);
+			enrichedEntries.push({ ...entry, prediction });
+		}
+
 		if (json) {
-			jsonOutput("merge", { entries: pendingEntries });
+			jsonOutput("merge", { entries: enrichedEntries });
 		} else {
 			process.stdout.write(
-				`${pendingEntries.length} pending branch${pendingEntries.length === 1 ? "" : "es"}:\n\n`,
+				`${enrichedEntries.length} pending branch${enrichedEntries.length === 1 ? "" : "es"}:\n\n`,
 			);
-			for (const entry of pendingEntries) {
-				process.stdout.write(`${formatDryRun(entry)}\n\n`);
+			for (const entry of enrichedEntries) {
+				process.stdout.write(`${formatDryRun(entry, entry.prediction)}\n\n`);
 			}
 		}
 		return;

package/src/commands/sling.test.ts

@@ -27,6 +27,8 @@ import {
 	isRunningAsRoot,
 	isTaskWorkable,
 	parentHasScouts,
+	parseSiblings,
+	resolveParentAgent,
 	resolveUseHeadless,
 	shouldShowScoutWarning,
 	validateHierarchy,
@@ -787,6 +789,48 @@ describe("isTaskWorkable", () => {
 	});
 });
 
+// --- resolveParentAgent (overstory-de3c) ---
+//
+// Witnessed bug: a coordinator/lead recovered a zombie spawn-per-turn worker
+// via `ov sling --recover --name <existing>` without threading `--parent`.
+// The pre-fix `parentAgent = opts.parent ?? null` overwrote the prior
+// `parent_agent` row to null on upsert, so the runner could not emit
+// `worker_died` on a resumed-turn parser stall — the lead waited forever.
+// The fix: when --parent is not explicitly passed, fall back to the prior
+// session row's parentAgent. Explicit caller intent (any string, including
+// empty) always wins.
+describe("resolveParentAgent", () => {
+	test("case A: explicit --parent wins over prior session linkage", () => {
+		const existing = { parentAgent: "old-lead" };
+		expect(resolveParentAgent("new-lead", existing)).toBe("new-lead");
+	});
+
+	test("case B: --parent omitted preserves prior session's parentAgent on re-spawn", () => {
+		// THE REGRESSION CHECK. Pre-fix this returned null, severing the link
+		// the runner needs to emit worker_died (overstory-de3c).
+		const existing = { parentAgent: "lead-r" };
+		expect(resolveParentAgent(undefined, existing)).toBe("lead-r");
+	});
+
+	test("--parent omitted with no prior session yields null (fresh agent)", () => {
+		expect(resolveParentAgent(undefined, null)).toBeNull();
+	});
+
+	test("--parent omitted with prior session whose parent is null yields null", () => {
+		// A coordinator-spawned root agent has parentAgent=null. Re-spawn must
+		// not synthesize a parent.
+		const existing = { parentAgent: null };
+		expect(resolveParentAgent(undefined, existing)).toBeNull();
+	});
+
+	test("explicit --parent='' (empty string) is honored — caller intent wins", () => {
+		// Empty string is `defined` but `null`-y; we honor it as caller intent
+		// rather than silently falling back to the prior linkage.
+		const existing = { parentAgent: "lead-r" };
+		expect(resolveParentAgent("", existing)).toBe("");
+	});
+});
+
 describe("checkDuplicateLead", () => {
 	test("returns lead agent name when an active lead exists for the task", () => {
 		const sessions = [
@@ -1167,6 +1211,7 @@ function makeAutoDispatchOpts(overrides?: Partial<AutoDispatchOptions>): AutoDis
 		capability: "builder",
 		specPath: "/path/to/spec.md",
 		parentAgent: "lead-alpha",
+		slingerName: null,
 		instructionPath: ".claude/CLAUDE.md",
 		...overrides,
 	};
@@ -1180,6 +1225,7 @@ describe("buildAutoDispatch", () => {
 			capability: "builder",
 			specPath: "/path/to/spec.md",
 			parentAgent: "lead-alpha",
+			slingerName: null,
 			instructionPath: ".claude/CLAUDE.md",
 		});
 		expect(dispatch.from).toBe("lead-alpha");
@@ -1195,6 +1241,7 @@ describe("buildAutoDispatch", () => {
 			capability: "lead",
 			specPath: null,
 			parentAgent: null,
+			slingerName: null,
 			instructionPath: ".claude/CLAUDE.md",
 		});
 		expect(dispatch.from).toBe("orchestrator");
@@ -1208,6 +1255,7 @@ describe("buildAutoDispatch", () => {
 			capability: "scout",
 			specPath: null,
 			parentAgent: "lead-alpha",
+			slingerName: null,
 			instructionPath: ".claude/CLAUDE.md",
 		});
 		expect(dispatch.body).toContain("scout");
@@ -1220,11 +1268,33 @@ describe("buildAutoDispatch", () => {
 			capability: "builder",
 			specPath: "/abs/path/to/spec.md",
 			parentAgent: "lead-alpha",
+			slingerName: null,
 			instructionPath: ".claude/CLAUDE.md",
 		});
 		expect(dispatch.body).toContain("/abs/path/to/spec.md");
 	});
 
+	test("slinger takes precedence over parent agent for from field", () => {
+		const dispatch = buildAutoDispatch(
+			makeAutoDispatchOpts({ slingerName: "coordinator", parentAgent: "lead-alpha" }),
+		);
+		expect(dispatch.from).toBe("coordinator");
+	});
+
+	test("slinger fills in when parent agent is null", () => {
+		const dispatch = buildAutoDispatch(
+			makeAutoDispatchOpts({ slingerName: "coordinator", parentAgent: null }),
+		);
+		expect(dispatch.from).toBe("coordinator");
+	});
+
+	test("falls back to orchestrator when both slinger and parent are null", () => {
+		const dispatch = buildAutoDispatch(
+			makeAutoDispatchOpts({ slingerName: null, parentAgent: null }),
+		);
+		expect(dispatch.from).toBe("orchestrator");
+	});
+
 	test("subject contains task ID", () => {
 		const dispatch = buildAutoDispatch(makeAutoDispatchOpts({ taskId: "overstory-zz99" }));
 		expect(dispatch.subject).toContain("overstory-zz99");
@@ -1477,3 +1547,37 @@ describe("resolveUseHeadless", () => {
 		expect(resolveUseHeadless(saplingLike, false, baseConfig)).toBe(true);
 	});
 });
+
+describe("parseSiblings (overstory-f76a)", () => {
+	test("undefined input returns empty array", () => {
+		expect(parseSiblings(undefined)).toEqual([]);
+	});
+
+	test("empty string returns empty array", () => {
+		expect(parseSiblings("")).toEqual([]);
+	});
+
+	test("single name returns one-element array", () => {
+		expect(parseSiblings("sibling-a")).toEqual(["sibling-a"]);
+	});
+
+	test("comma-separated names are split and trimmed", () => {
+		expect(parseSiblings("sibling-a, sibling-b ,sibling-c")).toEqual([
+			"sibling-a",
+			"sibling-b",
+			"sibling-c",
+		]);
+	});
+
+	test("blank entries between commas are dropped", () => {
+		expect(parseSiblings("sibling-a,,sibling-b, ,sibling-c")).toEqual([
+			"sibling-a",
+			"sibling-b",
+			"sibling-c",
+		]);
+	});
+
+	test("whitespace-only input returns empty array", () => {
+		expect(parseSiblings("   ")).toEqual([]);
+	});
+});