@ferris1225/pi-subagents 4.1.1 → 4.1.3

package/src/tools.ts

@@ -1,7 +1,7 @@
 /**
  * Thread controls and lookup tools around the subagent runtime:
- * subagent_control (steer/retarget/park/resume), subagent_wait (in-turn result
- * lookup), subagent_status, and destructive subagent_stop.
+ * subagent_control (steer/retarget/park/resume/fork), subagent_wait (in-turn
+ * result lookup), subagent_status, and destructive subagent_stop.
  */
 
 import { StringEnum } from "@earendil-works/pi-ai";
@@ -12,8 +12,7 @@ import { DEFAULT_MAX_RESULT_LINES, loadConfig } from "./config.ts";
 import { formatCompletionBlock, formatUsage, matchRunIds } from "./format.ts";
 import { emptyUsage } from "./rpc-run.ts";
 import {
-	formatElapsed,
-	formatUsageCompact,
+	formatTaskSummary,
 	isRunActiveStatus,
 	monitor,
 	runLabel,
@@ -51,7 +50,7 @@ export function registerLookupTools(pi: ExtensionAPI, runtime: SubagentRuntime):
 			Type.String({ description: "Instruction queued by steer after the current child tool batch." }),
 		),
 		objective: Type.Optional(
-			Type.String({ description: "Replacement objective for retarget, or optional objective for resume/fork." }),
+			Type.String({ description: "Replacement objective for retarget; optional appended objective for resume/fork. Omit on resume/fork to continue the current retained objective." }),
 		),
 	});
 
@@ -60,17 +59,18 @@ export function registerLookupTools(pi: ExtensionAPI, runtime: SubagentRuntime):
 		label: "Subagent Control",
 		description: [
 			"Control an existing sub-agent thread by stable run id.",
-			"steer queues an instruction after the current child tool batch.",
-			"retarget aborts the current objective to a stable checkpoint, suppresses that aborted completion, then starts the replacement objective in the same session.",
+			"steer queues an instruction after the current tool batch while the top-level RPC child is active.",
+			"retarget replaces the objective in that same active top-level child.",
+			"Managed downstream documenter/reviewer/fix stages are controlled by the parent queue rather than its settled RPC control: use park or stop there, then resume with an objective to redirect retained context.",
 			"park aborts to a stable checkpoint, terminates the child, preserves context, and releases its concurrency slot.",
-			"resume restarts a parked, completed, or failed retained thread with the same run id; objective is optional.",
-			"fork copies a parked/completed/failed retained session branch into a new logical thread and run id; an isolated checkpoint must be settled and integrated first; objective is optional.",
+			"resume restarts a parked, completed, or failed retained thread with the same run id and cumulative active time; omit objective to continue the current goal, or provide one to append it to retained context and make it the displayed current goal.",
+			"fork copies a parked/completed/failed retained session branch into a new logical thread and run id; an isolated checkpoint must be settled and integrated first; omit objective to continue the current goal, or provide one to append a new branch goal.",
 		].join(" "),
-		promptSnippet: "Control a subagent thread: steer, retarget, park, resume, or fork by stable run id.",
+		promptSnippet: "Control a subagent thread: steer/retarget an active top-level child; park/stop a managed downstream stage; resume or fork retained context.",
 		promptGuidelines: [
-			"Use subagent_control steer to refine active work without restarting it; the instruction is delivered after the child's current tool batch.",
-			"Use subagent_control retarget when the active objective is obsolete; do not call subagent_stop and start a fresh thread because retarget preserves context and suppresses the abandoned completion.",
-			"Use subagent_control park to checkpoint useful context while releasing the process/concurrency slot, and resume to continue the same run id later.",
+			"Use subagent_control steer to refine an active top-level RPC child without restarting it; the instruction is delivered after its current tool batch.",
+			"Use subagent_control retarget only while that top-level child is active. During a managed downstream stage, park it and resume with a replacement objective instead.",
+			"Use subagent_control park to checkpoint useful context while releasing the process/concurrency slot, and resume to continue the same run id later. Resume without objective keeps the current goal; resume with objective appends that goal to retained context.",
 			"Use subagent_control fork only on a parked or settled retained thread; isolated work must settle and integrate before it can fork. Fork creates a new run id while leaving the source untouched.",
 			"Use subagent_stop only for destructive cancellation; it retires that thread's retained session without retiring independent forks.",
 		],
@@ -109,13 +109,15 @@ export function registerLookupTools(pi: ExtensionAPI, runtime: SubagentRuntime):
 							thread.task = objective;
 							thread.control.retargetPending(objective);
 							monitor.setTask(thread.id, objective);
-							return { content: [{ type: "text", text: `Updated queued run #${thread.id} to the new objective; no child was spawned by this control action.` }], details: {} };
+							monitor.setContinuationKind(thread.id, "retarget");
+							return { content: [{ type: "text", text: `Updated queued run #${thread.id} to the replacement objective; no child was spawned by this control action.` }], details: {} };
 						}
 						if (!(["starting", "running", "steering", "interrupting", "retrying"] as const).includes(phase as any)) {
 							return { content: [{ type: "text", text: `Run #${thread.id} is ${thread.state}; use resume with objective to restart retained context.` }], details: {} };
 						}
 						thread.task = objective;
 						monitor.setTask(thread.id, objective);
+						monitor.setContinuationKind(thread.id, "retarget");
 						await thread.control.retarget(objective);
 						return { content: [{ type: "text", text: `Retargeted run #${thread.id} in the same session; the aborted objective will not be delivered as a completion.` }], details: {} };
 					}
@@ -145,11 +147,19 @@ export function registerLookupTools(pi: ExtensionAPI, runtime: SubagentRuntime):
 						if (params.objective !== undefined && !objective) {
 							return { content: [{ type: "text", text: "resume objective must be non-blank when provided." }], details: {} };
 						}
+						const hadRetainedSession = Boolean(thread.sessionId && thread.sessionDir);
 						const pending = await thread.resume(objective, ctx);
 						if (pending.exitCode !== -1) {
 							return { content: [{ type: "text", text: getResultOutput(pending) }], details: {} };
 						}
-						return { content: [{ type: "text", text: `Resumed run #${thread.id}${objective ? " with a new objective" : " from retained context"}; completion will arrive automatically.` }], details: {}, terminate: true };
+						const currentObjective = formatTaskSummary(objective ?? thread.task, 80, false);
+						const mode = objective
+							? `appended objective: ${currentObjective}`
+							: `continuing current objective: ${currentObjective}`;
+						const context = hadRetainedSession
+							? "the same retained session and prior context are preserved"
+							: "no prior child session existed, so only the logical run and objective are continued";
+						return { content: [{ type: "text", text: `Resumed run #${thread.id}, ${mode}; ${context}, and cumulative active time is preserved. Completion will arrive automatically.` }], details: {}, terminate: true };
 					}
 					case "fork": {
 						const objective = params.objective === undefined ? undefined : nonBlank(params.objective);
@@ -163,7 +173,7 @@ export function registerLookupTools(pi: ExtensionAPI, runtime: SubagentRuntime):
 						return {
 							content: [{
 								type: "text",
-								text: `Forked run #${thread.id} into new run #${pending.runId}${objective ? " with a new objective" : " from retained context"}; the source is unchanged and child completion will arrive automatically.`,
+								text: `Forked run #${thread.id} into new run #${pending.runId}; ${objective ? `appended branch objective: ${formatTaskSummary(objective, 80, false)}` : `continuing current objective: ${formatTaskSummary(thread.task, 80, false)}`}. Retained context is copied, the source is unchanged, and child completion will arrive automatically.`,
 							}],
 							details: { sourceRunId: thread.id, childRunId: pending.runId, result: pending },
 							terminate: true,
@@ -351,10 +361,7 @@ export function registerLookupTools(pi: ExtensionAPI, runtime: SubagentRuntime):
 	});
 
 	// Status overview: what is running right now and what finished this session,
-	// with per-run details (id, agent, model, usage, elapsed, activity) so the
-	// main agent can decide whether to wait, stop, or re-dispatch. Learned from
-	// nicobailon/pi-subagents ({action:"status"} + status files): inspect before
-	// you act, and report run ids when handing off.
+	// with per-run details (id, role, model, usage, elapsed, activity).
 	const SubagentStatusParams = Type.Object({
 		id: Type.Optional(
 			Type.String({
@@ -367,7 +374,7 @@ export function registerLookupTools(pi: ExtensionAPI, runtime: SubagentRuntime):
 		name: "subagent_status",
 		label: "Subagent Status",
 		description: [
-			"List active background sub-agent runs (id, agent, model, usage, elapsed, current activity) and recently finished results.",
+			"List active background sub-agent runs (id, role, model, thinking, usage, elapsed, current activity) and recently finished results.",
 			"Pass id to read the full result of a finished run; pass no id for the overview.",
 			"Use it to decide whether to subagent_wait, subagent_stop, or re-dispatch — never to poll: results arrive by themselves.",
 		].join(" "),
@@ -409,18 +416,32 @@ export function registerLookupTools(pi: ExtensionAPI, runtime: SubagentRuntime):
 				if (active) {
 					const parked = active.status === "parked";
 					const activeThread = runtime.threads.get(active.id);
+					const managedDownstream =
+						activeThread?.state === "running" && activeThread.control.getPhase() === "settled";
+					const activeChild = runs.find((run) =>
+						run.parentRunId === active.id && isRunActiveStatus(run.status)
+					);
+					const owner = active.managedWorkflow ? `${active.agent} workflow` : active.agent;
+					const retainedStage = active.managedWorkflow && activeThread?.agentName !== active.agent
+						? activeThread?.agentName
+						: undefined;
 					const metadata = [
 						activeThread?.isolation === "worktree" ? `worktree ${active.integrationStatus ?? activeThread.worktree?.state ?? "active"}` : undefined,
 						activeThread?.forkedFromRunId !== undefined ? `forked from #${activeThread.forkedFromRunId}` : undefined,
 						(activeThread?.forkChildRunIds.length ?? 0) > 0 ? `forks ${activeThread!.forkChildRunIds.map((id) => `#${id}`).join(",")}` : undefined,
 					].filter(Boolean).join(" · ");
+					const stageStatus = activeChild
+						? monitor.summarize(activeChild)
+						: active.activity ?? statusLabel(active.status);
 					return {
 						content: [
 							{
 								type: "text",
 								text: parked
-									? `Run #${active.id} ${active.agent} is parked with retained context${metadata ? ` (${metadata})` : ""}. Use subagent_control resume to restart it, or subagent_stop to retire it.`
-									: `Run #${active.id} ${active.agent} is still active (${active.activity ?? statusLabel(active.status)}${metadata ? ` · ${metadata}` : ""}). Use subagent_wait to block for its result, subagent_control to steer/park it, or subagent_stop to cancel it.`,
+									? `Run #${active.id} ${owner} is parked with retained${retainedStage ? ` ${retainedStage} stage` : ""} context${metadata ? ` (${metadata})` : ""}. Use subagent_control resume to restart it, or subagent_stop to retire it.`
+									: managedDownstream
+										? `Run #${active.id} ${owner} is in a managed downstream stage (${stageStatus}${metadata ? ` · ${metadata}` : ""}). Use subagent_wait for its result, subagent_control park to checkpoint it, or subagent_stop to cancel it. Steer/retarget are unavailable until you park and resume the retained stage.`
+										: `Run #${active.id} ${owner} is still active (${active.activity ?? statusLabel(active.status)}${metadata ? ` · ${metadata}` : ""}). Use subagent_wait to block for its result, subagent_control to steer/park it, or subagent_stop to cancel it.`,
 							},
 						],
 						details: {},
@@ -429,36 +450,34 @@ export function registerLookupTools(pi: ExtensionAPI, runtime: SubagentRuntime):
 				return { content: [{ type: "text", text: `No subagent run matches "${requested}".` }], details: {} };
 			}
 
-			const now = Date.now();
 			const activeRuns = monitor.getRuns().filter(
 				(run) => isRunActiveStatus(run.status),
 			);
 			const activeLines = activeRuns.map((run) => {
 				const thread = runtime.threads.get(run.id);
-				const model = run.modelFallbackFrom
-					? `${run.model ?? "?"} (main after ${run.modelFallbackFrom} failed)`
-					: (run.model ?? "?");
 				const parts = [
-					`#${run.id} ${run.agent}`,
+					`#${run.id} ${monitor.summarize(run)}`,
 					run.label,
-					model,
-					formatUsageCompact(run.usage),
-					formatElapsed(run, now),
-					thread?.isolation === "worktree" ? `worktree ${run.integrationStatus ?? thread.worktree?.state ?? "active"}` : undefined,
 					thread?.forkedFromRunId !== undefined ? `forked from #${thread.forkedFromRunId}` : undefined,
 					(thread?.forkChildRunIds.length ?? 0) > 0 ? `forks ${thread!.forkChildRunIds.map((id) => `#${id}`).join(",")}` : undefined,
+					run.activity ?? statusLabel(run.status),
 				].filter(Boolean);
-				return `- ${parts.join(" · ")} · ${run.activity ?? statusLabel(run.status)}`;
+				return `- ${parts.join(" · ")}`;
 			});
 			const parkedThreads = [...runtime.threads.values()].filter((thread) => thread.state === "parked");
 			const parkedLines = parkedThreads.map((thread) => {
+				const run = monitor.findRun(thread.id);
+				const owner = run?.managedWorkflow ? `${run.agent} workflow` : run?.agent ?? thread.agentName;
+				const retainedStage = run?.managedWorkflow && thread.agentName !== run.agent
+					? ` · retained stage ${thread.agentName}`
+					: "";
 				const relations = [
 					thread.forkedFromRunId !== undefined ? `forked from #${thread.forkedFromRunId}` : undefined,
 					thread.forkChildRunIds.length > 0 ? `forks ${thread.forkChildRunIds.map((id) => `#${id}`).join(",")}` : undefined,
 				].filter(Boolean);
 				const relation = relations.length > 0 ? ` · ${relations.join(" · ")}` : "";
 				const isolation = thread.isolation === "worktree" ? ` · worktree ${thread.worktree?.state ?? "active"}` : "";
-				return `- #${thread.id} ${thread.agentName} · ${runLabel(thread.task)} · parked${thread.sessionDir ? " · context retained" : " · not started"}${isolation}${relation}`;
+				return `- #${thread.id} ${owner} · ${run?.label ?? runLabel(thread.task)} · parked${thread.sessionDir ? " · context retained" : " · not started"}${retainedStage}${isolation}${relation}`;
 			});
 			const completed = [...runtime.settledRuns.entries()].slice(-5);
 			const completedLines = completed.map(([id, result]) => {
@@ -617,9 +636,19 @@ export function registerLookupTools(pi: ExtensionAPI, runtime: SubagentRuntime):
 				});
 			}
 
+			// Interrupt every claimed generation before awaiting any one of them.
+			// An isolated stop may need the repository lane for final integration;
+			// cancelling all holders first prevents stop-all from waiting behind a
+			// later shared workflow that this same operation has not interrupted yet.
+			const interruptionPromises = claimed.map(({ thread, stopMessage, controller }) => {
+				const stopping = thread.control.stop(stopMessage).catch(() => undefined);
+				runtime.backgroundQueue.cancel(controller);
+				return stopping;
+			});
+
 			const stopped: string[] = [];
 			const retainedIntegration: string[] = [];
-			for (const claim of claimed) {
+			for (const [claimIndex, claim] of claimed.entries()) {
 				const {
 					runId,
 					thread,
@@ -634,8 +663,7 @@ export function registerLookupTools(pi: ExtensionAPI, runtime: SubagentRuntime):
 					stopVersion,
 					stopMessage,
 				} = claim;
-				await thread.control.stop(stopMessage).catch(() => undefined);
-				runtime.backgroundQueue.cancel(controller);
+				await interruptionPromises[claimIndex];
 				await completion;
 				if (runtime.runControllers.get(runId) === controller) runtime.runControllers.delete(runId);
 				if (thread.queueController === controller) thread.queueController = undefined;

package/src/widget.ts

@@ -3,6 +3,7 @@
 import type { ExtensionContext, Theme } from "@earendil-works/pi-coding-agent";
 import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
 import {
+	continuationLabel,
 	formatElapsed,
 	formatTaskSummary,
 	isRunActiveStatus,
@@ -25,10 +26,22 @@ function compactLine(left: string, right: string, width: number): string {
 	return `${truncateToWidth(left, leftWidth, "…")}${separator}${right}`;
 }
 
+/** Keep continuation semantics intact while independently compacting the task. */
+function formatContinuationTask(label: string, task: string, width: number): string {
+	if (width <= 0) return "";
+	const labelWidth = visibleWidth(label);
+	if (labelWidth >= width) return truncateToWidth(label, width, "");
+	const separator = " · ";
+	const taskWidth = width - labelWidth - visibleWidth(separator);
+	if (taskWidth <= 0) return label;
+	const summary = formatTaskSummary(task, taskWidth);
+	return summary ? `${label}${separator}${summary}` : label;
+}
+
 /** One compact primary line per genuinely active run, plus an optional indented
- * activity line. The primary line reserves effective model/thinking and elapsed
- * width before truncating the task. Settled and parked threads never appear, so
- * elapsed time cannot keep ticking beside a terminal status. */
+ * activity line. The primary line reserves stage model/thinking when present and
+ * elapsed width before truncating the task. Settled and parked threads never
+ * appear, so elapsed time cannot keep ticking beside a terminal status. */
 function runPrimaryLine(
 	run: RunView,
 	theme: Theme,
@@ -38,22 +51,31 @@ function runPrimaryLine(
 ): string {
 	const dim = (text: string): string => theme.fg("dim", text);
 	const icon = statusIcon(run.status, theme);
-	const name = theme.fg("accent", theme.bold(run.agent));
+	const displayName = run.managedWorkflow ? `${run.agent} workflow` : run.agent;
+	const name = theme.fg("accent", theme.bold(displayName));
 	const identity = `${prefix}${icon} ${name}`;
 	const elapsed = formatElapsed(run, now);
 	// Render only the resolved model id plus thinking level. Provider auth and
 	// other configuration never enter monitor state or this line.
 	const modelId = run.model?.split("/").at(-1);
-	const modelSource = formatTaskSummary(
-		modelId ? `${modelId}${run.thinking ? `/${run.thinking}` : ""}` : run.thinking ? `thinking:${run.thinking}` : "",
-		64,
-		false,
-	);
+	const modelSource = run.managedWorkflow
+		? ""
+		: formatTaskSummary(
+			modelId ? `${modelId}${run.thinking ? `/${run.thinking}` : ""}` : run.thinking ? `thinking:${run.thinking}` : "",
+			64,
+			false,
+		);
 	// A chain child shows its role in the chain plus a task-derived label; the
 	// templated fix brief itself would only repeat the parent review's content.
+	const continuation = run.parentRunId === undefined
+		? continuationLabel(run.continuationKind, run.forkedFromRunId)
+		: undefined;
 	const taskSource = run.parentRunId !== undefined
 		? [run.relationLabel, run.label].filter((part): part is string => Boolean(part)).join(" · ")
 		: formatTaskSummary(run.task, 64);
+	const taskDesiredSource = [continuation, taskSource]
+		.filter((part): part is string => Boolean(part))
+		.join(" · ");
 	const primaryPartCount = 2 + (modelSource ? 1 : 0) + (elapsed ? 1 : 0);
 	const contentWidth = Math.max(
 		0,
@@ -64,15 +86,40 @@ function runPrimaryLine(
 	);
 	const modelDesired = visibleWidth(modelSource);
 	const modelFloor = Math.min(modelDesired, Math.min(12, contentWidth));
-	let modelWidth = modelSource
-		? Math.min(modelDesired, Math.max(modelFloor, contentWidth - 8))
-		: 0;
+	let modelWidth = 0;
+	if (modelSource) {
+		if (continuation) {
+			const continuationWidth = visibleWidth(continuation);
+			// Preserve the full semantic label and the usual eight-column task tail
+			// before giving the remaining space to model/thinking.
+			const taskFloor = Math.min(
+				visibleWidth(taskDesiredSource),
+				continuationWidth +
+					(taskSource ? visibleWidth(" · ") + Math.min(8, visibleWidth(taskSource)) : 0),
+				contentWidth,
+			);
+			const effectiveModelFloor = Math.min(
+				modelFloor,
+				Math.max(0, contentWidth - continuationWidth),
+			);
+			modelWidth = Math.min(
+				modelDesired,
+				Math.max(effectiveModelFloor, contentWidth - taskFloor),
+			);
+		} else {
+			modelWidth = Math.min(modelDesired, Math.max(modelFloor, contentWidth - 8));
+		}
+	}
 	let taskWidth = contentWidth - modelWidth;
-	if (visibleWidth(taskSource) < taskWidth) {
-		modelWidth = Math.min(modelDesired, modelWidth + taskWidth - visibleWidth(taskSource));
+	if (visibleWidth(taskDesiredSource) < taskWidth) {
+		modelWidth = Math.min(modelDesired, modelWidth + taskWidth - visibleWidth(taskDesiredSource));
 		taskWidth = contentWidth - modelWidth;
 	}
-	const task = taskWidth > 0 ? formatTaskSummary(taskSource, taskWidth, run.parentRunId === undefined) : "";
+	const task = taskWidth <= 0
+		? ""
+		: continuation
+			? formatContinuationTask(continuation, taskSource, taskWidth)
+			: formatTaskSummary(taskSource, taskWidth, run.parentRunId === undefined);
 	const modelThinking = modelWidth > 0 ? formatTaskSummary(modelSource, modelWidth, false) : "";
 	const primaryLeft = [
 		identity,
@@ -93,10 +140,9 @@ function runActivityLine(run: RunView, theme: Theme, width: number, indent: stri
 	return [truncateToWidth(`${indent}${dim(activitySummary)}`, width, "")];
 }
 
-/** Render active runs as a tree: main-agent dispatches are roots, auto-fix chain
- * rounds nest under the triggering reviewer row that owns the chain. No run ids
- * appear here — the tree and the task label say what each row is, and ids stay
- * available through subagent_status when a thread must be controlled. */
+/** Render active runs as a tree: main-agent dispatches are roots and managed
+ * documenter/reviewer/fix steps nest under the stable parent row. Fork labels
+ * include their source id; other control ids remain available through status. */
 export function formatActiveRunLines(
 	runs: readonly RunView[],
 	theme: Theme,
@@ -120,8 +166,8 @@ export function formatActiveRunLines(
 	for (const root of roots) {
 		const children = childrenOf.get(root.id) ?? [];
 		lines.push(runPrimaryLine(root, theme, width, now, ""));
-		// The parent's "auto-fix chain running" placeholder is redundant while its
-		// child rows show live progress; keep it only between rounds.
+		// The parent's managed-workflow placeholder is redundant while a child
+		// row shows live progress; keep it only between stages.
 		if (children.length === 0) lines.push(...runActivityLine(root, theme, width, "  "));
 		children.forEach((child, index) => {
 			const connector = index === children.length - 1 ? "└ " : "├ ";
@@ -134,7 +180,7 @@ export function formatActiveRunLines(
 
 function hasTickingRun(): boolean {
 	return monitor.getRuns().some(
-		(run) => isRunActiveStatus(run.status) && run.startedAt !== undefined,
+		(run) => isRunActiveStatus(run.status) && run.activeSince !== undefined,
 	);
 }
 

package/src/worktree.ts

@@ -298,11 +298,18 @@ export function isPathInside(root: string, candidate: string): boolean {
 	return rel === "" || (!rel.startsWith("..") && !isAbsolute(rel));
 }
 
-/** Resolve and validate the Git repository/worktree that contains cwd. */
-export async function resolveWorktreeTarget(
+interface RepositoryLocation {
+	originalCwd: string;
+	originalRoot: string;
+}
+
+/** Resolve the canonical repository root without requiring a committed HEAD.
+ * Managed repository lanes use this for empty repositories as well as normal
+ * worktrees; worktree creation validates HEAD separately below. */
+async function resolveRepositoryLocation(
 	cwd: string,
-	runner: CommandRunner = runCommand,
-): Promise<WorktreeTarget> {
+	runner: CommandRunner,
+): Promise<RepositoryLocation> {
 	const requested = resolve(cwd);
 	try {
 		if (!(await stat(requested)).isDirectory()) throw new Error("not a directory");
@@ -335,6 +342,22 @@ export async function resolveWorktreeTarget(
 			`Requested cwd ${originalCwd} is not inside Git worktree root ${originalRoot}.`,
 		);
 	}
+	return { originalCwd, originalRoot };
+}
+
+export async function resolveRepositoryRoot(
+	cwd: string,
+	runner: CommandRunner = runCommand,
+): Promise<string> {
+	return (await resolveRepositoryLocation(cwd, runner)).originalRoot;
+}
+
+/** Resolve and validate the Git repository/worktree that contains cwd. */
+export async function resolveWorktreeTarget(
+	cwd: string,
+	runner: CommandRunner = runCommand,
+): Promise<WorktreeTarget> {
+	const { originalCwd, originalRoot } = await resolveRepositoryLocation(cwd, runner);
 	let headResult: CommandResult;
 	try {
 		headResult = await runGit(