@henryqw/pi-herdr-clone 0.2.0 → 0.2.2

package/README.md

@@ -26,9 +26,11 @@ Both commands wait until Pi is idle, then validate the current Herdr pane (`HERD
 ### `/clone-worktree` behavior
 
 1. Creates a Git worktree-backed workspace with `herdr worktree create --workspace <current-workspace> --no-focus`; Herdr creates the branch from `HEAD` unless the name exists, checks out the worktree under its configured `worktrees.directory`, and opens it as a grouped workspace.
-2. Copies the active path into a clone session stamped with the fresh checkout path as its working directory.
-3. Starts Pi in the new workspace's root pane (whose shell runs inside the checkout) with `--session <absolute-clone-file>`.
-4. Focuses the new tab after Pi starts successfully.
+2. Waits briefly for any worktree-layout plugin (for example `herdr-plus`) to start its own agent in the new workspace's root pane.
+3. If the root pane is occupied, creates an additional unfocused tab in the new workspace with the checkout as its working directory, so the plugin's agent and the clone coexist. Otherwise the clone uses the root pane.
+4. Copies the active path into a clone session stamped with the fresh checkout path as its working directory.
+5. Starts Pi in the chosen pane with `--session <absolute-clone-file>`.
+6. Focuses the clone's tab after Pi starts successfully.
 
 ### Failure semantics
 

package/extensions/clone-tab.ts

@@ -18,7 +18,11 @@ import {
 
 type WorkspaceInfo = {
 	workspace_id?: unknown;
-	worktree?: { checkout_path?: unknown } | null;
+	worktree?: {
+		checkout_path?: unknown;
+		repo_root?: unknown;
+		is_linked_worktree?: unknown;
+	} | null;
 };
 
 const errorMessage = (error: unknown) => error instanceof Error ? error.message : String(error);
@@ -33,6 +37,8 @@ type SourceContext = {
 	leafId: string;
 	workspaceId: string;
 	checkout: string | undefined;
+	repoRoot: string | undefined;
+	isLinkedWorktree: boolean;
 };
 
 async function resolveSource(
@@ -70,7 +76,14 @@ async function resolveSource(
 	const checkout = workspace?.worktree == null
 		? undefined
 		: requiredString(workspace.worktree.checkout_path, "Herdr workspace response checkout_path");
-	return { sessionFile, leafId, workspaceId, checkout };
+	const repoRoot = typeof workspace?.worktree?.repo_root === "string" && workspace.worktree.repo_root.trim()
+		? workspace.worktree.repo_root
+		: undefined;
+	const isLinkedWorktree = workspace?.worktree?.is_linked_worktree === true;
+	if (isLinkedWorktree && !repoRoot) {
+		throw new Error("Herdr workspace response is missing worktree.repo_root for a linked worktree.");
+	}
+	return { sessionFile, leafId, workspaceId, checkout, repoRoot, isLinkedWorktree };
 }
 
 async function createBranchedClone(
@@ -92,6 +105,46 @@ async function createBranchedClone(
 	return cloneFile;
 }
 
+// A worktree layout plugin (e.g. herdr-plus) can start its own agent in a new
+// worktree's root pane right after creation. Give it a moment to appear so the
+// clone can move to its own tab instead of failing with agent_pane_busy.
+async function waitForRootPaneAgent(
+	herdr: HerdrClient<{ cwd: string }>,
+	ctx: ExtensionCommandContext,
+	paneId: string,
+): Promise<string | undefined> {
+	for (let attempt = 0; attempt < 12; attempt += 1) {
+		const response = await herdr.json(["pane", "get", paneId], { cwd: ctx.cwd });
+		const agent = (response as { result?: { pane?: { agent?: unknown } } }).result?.pane?.agent;
+		if (typeof agent === "string" && agent.trim()) return agent;
+		await delay(250);
+	}
+	return undefined;
+}
+
+function parseCreatedTab(createdTab: HerdrExecResult, workspaceId: string): { tabId: string; rootPaneId: string } {
+	let tabId: string | undefined;
+	let rootPaneId: string | undefined;
+	try {
+		const response: unknown = JSON.parse(createdTab.stdout);
+		if (!response || typeof response !== "object" || Array.isArray(response)) {
+			throw new Error("Herdr tab create returned invalid JSON");
+		}
+		const result = (response as { result?: { tab?: { tab_id?: unknown }; root_pane?: { pane_id?: unknown } } }).result;
+		tabId = typeof result?.tab?.tab_id === "string" && result.tab.tab_id.trim() ? result.tab.tab_id : undefined;
+		rootPaneId = typeof result?.root_pane?.pane_id === "string" && result.root_pane.pane_id.trim()
+			? result.root_pane.pane_id
+			: undefined;
+		const missing = [!tabId && "tab_id", !rootPaneId && "root_pane.pane_id"].filter(Boolean).join(", ");
+		if (missing) throw new Error(`Herdr tab create response is missing ${missing}.`);
+		return { tabId: tabId!, rootPaneId: rootPaneId! };
+	} catch (error) {
+		const retained = [`workspace ${workspaceId}`, tabId && `tab ${tabId}`, rootPaneId && `root pane ${rootPaneId}`]
+			.filter(Boolean).join(", ");
+		throw new Error(`Herdr tab create response could not be parsed; retained ${retained}: ${errorMessage(error)}`, { cause: error });
+	}
+}
+
 async function discardCloneOrAggregate(cloneFile: string, error: Error): Promise<never> {
 	try {
 		await unlink(cloneFile);
@@ -110,16 +163,22 @@ async function launchCloneAgent(
 	rootPaneId: string,
 	cloneFile: string,
 	retained: string,
+	onPaneBusy?: () => Promise<{ rootPaneId: string; retained: string }>,
 ): Promise<string> {
 	const agentName = `clone-${randomUUID().replaceAll("-", "").slice(0, 24)}`;
-	const startArgs = [
-		"agent", "start", agentName, "--kind", "pi", "--pane", rootPaneId,
-		"--", "--session", cloneFile,
-	];
 	try {
 		for (let attempt = 1; attempt <= 5; attempt += 1) {
+			const startArgs = [
+				"agent", "start", agentName, "--kind", "pi", "--pane", rootPaneId,
+				"--", "--session", cloneFile,
+			];
 			const result = await herdr.exec(startArgs, { cwd: ctx.cwd });
 			if (result.code === 0 && !result.killed) return agentName;
+			if (hasHerdrErrorCode(result, "agent_pane_busy") && onPaneBusy) {
+				({ rootPaneId, retained } = await onPaneBusy());
+				onPaneBusy = undefined;
+				continue;
+			}
 			if (!hasHerdrErrorCode(result, "agent_pane_busy") || attempt === 5) {
 				throw new Error(herdrCommandFailure(startArgs, result));
 			}
@@ -195,10 +254,23 @@ export default function herdrCloneExtension(pi: ExtensionAPI): void {
 			await ctx.waitForIdle();
 			const source = await resolveSource("clone-worktree", herdr, ctx);
 
+			// Herdr only creates worktrees from the repo parent workspace; running
+			// /clone-worktree inside a linked worktree must retarget the parent.
+			let targetWorkspaceId = source.workspaceId;
+			if (source.isLinkedWorktree) {
+				const listing = await herdr.json(["workspace", "list"], { cwd: ctx.cwd });
+				const result = (listing as { result?: { workspaces?: WorkspaceInfo[] } }).result;
+				const parent = (Array.isArray(result?.workspaces) ? result.workspaces : []).find((entry) =>
+					entry.worktree != null && !entry.worktree.is_linked_worktree &&
+					entry.worktree.checkout_path === source.repoRoot);
+				targetWorkspaceId = typeof parent?.workspace_id === "string"
+					? parent.workspace_id
+					: requiredString(undefined, `Repo parent workspace for ${source.repoRoot} in herdr workspace list`);
+			}
 			// Create the worktree before the clone so the session header can be
 			// stamped with the fresh checkout cwd. A killed or incomplete create is
 			// ambiguous: Herdr may have retained partial worktree state.
-			const worktreeCreateArgs = ["worktree", "create", "--workspace", source.workspaceId, "--no-focus"] as const;
+			const worktreeCreateArgs = ["worktree", "create", "--workspace", targetWorkspaceId, "--no-focus"] as const;
 			const createdWorktree = await herdr.exec(worktreeCreateArgs, { cwd: ctx.cwd });
 			if (createdWorktree.code !== 0 && !createdWorktree.killed) {
 				throw new Error(herdrCommandFailure(worktreeCreateArgs, createdWorktree));
@@ -249,6 +321,20 @@ export default function herdrCloneExtension(pi: ExtensionAPI): void {
 				);
 			}
 
+			// A layout plugin may have claimed the root pane; park the clone in its
+			// own tab so both agents coexist.
+			let targetTabId = tabId!;
+			let targetPaneId = rootPaneId!;
+			const createCloneTab = async (): Promise<void> => {
+				const cloneTabArgs = ["tab", "create", "--workspace", workspaceId!, "--cwd", checkoutPath!, "--no-focus"] as const;
+				const createdTab = await herdr.exec(cloneTabArgs, { cwd: ctx.cwd });
+				if (createdTab.code !== 0 || createdTab.killed) {
+					throw new Error(herdrCommandFailure(cloneTabArgs, createdTab));
+				}
+				({ tabId: targetTabId, rootPaneId: targetPaneId } = parseCreatedTab(createdTab, workspaceId!));
+			};
+			if (await waitForRootPaneAgent(herdr, ctx, rootPaneId!)) await createCloneTab();
+
 			let cloneFile: string;
 			try {
 				cloneFile = source.checkout
@@ -261,21 +347,28 @@ export default function herdrCloneExtension(pi: ExtensionAPI): void {
 				);
 			}
 			const agentName = await launchCloneAgent(
-				herdr, ctx, rootPaneId!, cloneFile,
-				`Herdr workspace ${workspaceId}, tab ${tabId}, root pane ${rootPaneId}, and session ${cloneFile}`,
+				herdr, ctx, targetPaneId, cloneFile,
+				`Herdr workspace ${workspaceId}, tab ${targetTabId}, root pane ${targetPaneId}, and session ${cloneFile}`,
+				targetPaneId === rootPaneId ? async () => {
+					await createCloneTab();
+					return {
+						rootPaneId: targetPaneId,
+						retained: `Herdr workspace ${workspaceId}, tab ${targetTabId}, root pane ${targetPaneId}, and session ${cloneFile}`,
+					};
+				} : undefined,
 			);
 
 			try {
-				await herdr.run(["tab", "focus", tabId!], { cwd: ctx.cwd });
+				await herdr.run(["tab", "focus", targetTabId], { cwd: ctx.cwd });
 			} catch (error) {
 				ctx.ui.notify(
-					`Clone agent ${agentName} started in Herdr worktree workspace ${workspaceId} (tab ${tabId}, checkout ${checkoutPath}), but focus failed: ${errorMessage(error)}`,
+					`Clone agent ${agentName} started in Herdr worktree workspace ${workspaceId} (tab ${targetTabId}, checkout ${checkoutPath}), but focus failed: ${errorMessage(error)}`,
 					"warning",
 				);
 				return;
 			}
 			ctx.ui.notify(
-				`Cloned current conversation into Herdr worktree workspace ${workspaceId} (tab ${tabId}, checkout ${checkoutPath}, agent ${agentName}).`,
+				`Cloned current conversation into Herdr worktree workspace ${workspaceId} (tab ${targetTabId}, checkout ${checkoutPath}, agent ${agentName}).`,
 				"info",
 			);
 		},

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@henryqw/pi-herdr-clone",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "Clone the current Pi conversation path into a new Herdr tab.",
   "keywords": [
     "pi-package",