@norman-else/dsh-claude 0.1.47 → 0.1.48

package/lib/index.mjs

@@ -4560,8 +4560,10 @@ const MAX_UNTRACKED_DIFFS = 50;
 const GIT_TIMEOUT_MS$3 = 5e3;
 const GH_TIMEOUT_MS$1 = 8e3;
 const CACHE_TTL_MS = 5e3;
+const PULL_REQUEST_TTL_FACTOR = 12;
 const MAX_TEXT_CHARS = 1024;
 const MAX_CONFLICT_PATHS = 100;
+const PULL_REQUEST_FIELDS = "number,title,url,state,isDraft,reviewDecision,mergeStateStatus,mergedAt,statusCheckRollup,author,createdAt,baseRefName,headRefName,additions,deletions,changedFiles";
 function bounded(value) {
 	return value.trim().slice(0, MAX_TEXT_CHARS);
 }
@@ -4761,6 +4763,7 @@ function parsePullRequest(value) {
 		review: reviewState(input.reviewDecision),
 		checks: aggregateChecks(input.statusCheckRollup),
 		...typeof input.mergeStateStatus === "string" ? { mergeState: bounded(input.mergeStateStatus) } : {},
+		...typeof input.headRefName === "string" && input.headRefName.length > 0 ? { headBranch: bounded(input.headRefName) } : {},
 		...typeof record$11(input.author)?.login === "string" ? { author: bounded(String(record$11(input.author)?.login)) } : {},
 		...typeof input.createdAt === "string" && Number.isFinite(Date.parse(input.createdAt)) ? { createdAt: new Date(input.createdAt).toISOString() } : {},
 		...typeof input.mergedAt === "string" && Number.isFinite(Date.parse(input.mergedAt)) ? { mergedAt: new Date(input.mergedAt).toISOString() } : {},
@@ -4801,6 +4804,75 @@ var RepositoryStatusService = class {
 		value.catch(() => this.#cache.delete(cwd));
 		return value;
 	}
+	/** One pull request by number, as the checkout-shaped status the panels
+	*  read: a session that opened a pull request in another repository and
+	*  then moved that checkout back to its base branch still has the pull
+	*  request. No root, no diff; `cwd` is only where gh runs. Same cache and
+	*  stabilisation as `inspect`, keyed off the pull request. */
+	inspectPullRequest(cwd, repository, number) {
+		const key = `gh:${repository}#${number}`;
+		const current = this.#cache.get(key);
+		if (current !== void 0 && current.expiresAt > Date.now()) return current.value;
+		const value = (async () => {
+			const gh = await this.#gh();
+			if (gh === void 0) return {
+				status: "unavailable",
+				cwd
+			};
+			const result = await run(this.#runtime, gh, [
+				"pr",
+				"view",
+				String(number),
+				"--repo",
+				repository,
+				"--json",
+				PULL_REQUEST_FIELDS
+			], cwd, GH_TIMEOUT_MS$1);
+			const raw = result.exitCode === 0 ? JSON.parse(result.stdout) : void 0;
+			const pullRequest = parsePullRequest(raw);
+			if (pullRequest === void 0) return {
+				status: "unavailable",
+				cwd
+			};
+			const counts = record$11(raw);
+			const count = (value) => typeof value === "number" && Number.isSafeInteger(value) && value >= 0 ? value : 0;
+			const patch = await run(this.#runtime, gh, [
+				"pr",
+				"diff",
+				String(number),
+				"--repo",
+				repository
+			], cwd, GH_TIMEOUT_MS$1, MAX_RAW_DIFF_BYTES);
+			const packed = patch.exitCode === 0 && !patch.lossy ? packPatchByFile(patch.stdout) : void 0;
+			return {
+				status: "ready",
+				cwd,
+				remote: repository,
+				...pullRequest.headBranch === void 0 ? {} : { branch: pullRequest.headBranch },
+				detached: false,
+				worktree: false,
+				dirty: false,
+				pullRequest,
+				pullRequestOnly: true,
+				diff: {
+					additions: count(counts?.additions),
+					deletions: count(counts?.deletions),
+					files: count(counts?.changedFiles),
+					...packed === void 0 ? {} : { patch: packed.patch },
+					...packed === void 0 || packed.elided.length === 0 ? {} : { elided: packed.elided },
+					truncated: packed === void 0
+				}
+			};
+		})().then((next) => this.#stabilize(key, next), () => ({
+			status: "unavailable",
+			cwd
+		}));
+		this.#cache.set(key, {
+			expiresAt: Date.now() + this.#cacheTtlMs * PULL_REQUEST_TTL_FACTOR,
+			value
+		});
+		return value;
+	}
 	invalidate(cwd) {
 		this.#cache.delete(cwd);
 		this.#lastReady.delete(cwd);
@@ -5080,7 +5152,7 @@ var RepositoryStatusService = class {
 				"--repo",
 				repository,
 				"--json",
-				"number,title,url,state,isDraft,reviewDecision,mergeStateStatus,mergedAt,statusCheckRollup,author,createdAt,baseRefName"
+				PULL_REQUEST_FIELDS
 			], cwd, GH_TIMEOUT_MS$1);
 			if (result.exitCode !== 0) return void 0;
 			return parsePullRequest(JSON.parse(result.stdout));
@@ -5338,9 +5410,16 @@ var RepositorySetupService = class {
 	/** Tear down a merged branch: remove a plugin worktree (and its lease and
 	*  branch), or switch a plain checkout back to the base branch and delete
 	*  the merged branch. Refuses dirty trees. */
-	async cleanupMerged(pathValue, baseBranch) {
+	/** `branch` names the merged branch when the checkout is no longer on it:
+	*  a session that opened a pull request in another clone switched that
+	*  clone back to base itself, and only the local branch is left to delete.
+	*  `requirePushed` is for a branch no pull request vouches for: it is only
+	*  removed once every commit on it is reachable from some remote, so a
+	*  worktree that never got as far as a pull request cannot take work with it. */
+	async cleanupMerged(pathValue, baseBranch, branch, requirePushed = false) {
 		const path = safePath(pathValue);
-		const base = safeBranch(baseBranch);
+		const base = baseBranch === void 0 ? void 0 : safeBranch(baseBranch);
+		const named = branch === void 0 ? void 0 : safeBranch(branch);
 		const git = await this.#git();
 		const status = await this.#run(git, [
 			"status",
@@ -5350,36 +5429,56 @@ var RepositorySetupService = class {
 		if (status.exitCode !== 0 || status.lossy) throw new RepositorySetupError("repository-unavailable", "The repository state is unavailable.");
 		if (status.stdout.trim().length > 0) throw new RepositorySetupError("dirty-workspace", "Commit or stash workspace changes before cleaning up.");
 		const lease = (await this.#readLeases()).find((item) => comparablePath(item.path) === comparablePath(path));
-		if (lease !== void 0) return this.#serialize(async () => {
-			if ((await this.#run(git, [
-				"worktree",
-				"remove",
-				"--",
-				lease.path
-			], lease.root)).exitCode !== 0) throw new RepositorySetupError("worktree-remove-failed", "Git could not remove the worktree.");
-			await this.#run(git, [
-				"branch",
-				"-D",
-				"--",
-				lease.branch
-			], lease.root).catch(() => void 0);
-			const current = await this.#readLeases();
-			await this.#writeLeases(current.filter((item) => item.id !== lease.id));
-			return {
-				mode: "worktree",
-				root: lease.root,
-				branch: lease.branch
-			};
-		});
+		if (lease !== void 0) {
+			if (requirePushed) await this.#requirePushed(git, lease.root, lease.branch);
+			return this.#serialize(async () => {
+				if ((await this.#run(git, [
+					"worktree",
+					"remove",
+					"--",
+					lease.path
+				], lease.root)).exitCode !== 0) throw new RepositorySetupError("worktree-remove-failed", "Git could not remove the worktree.");
+				await this.#run(git, [
+					"branch",
+					"-D",
+					"--",
+					lease.branch
+				], lease.root).catch(() => void 0);
+				const current = await this.#readLeases();
+				await this.#writeLeases(current.filter((item) => item.id !== lease.id));
+				return {
+					mode: "worktree",
+					root: lease.root,
+					branch: lease.branch
+				};
+			});
+		}
 		const root = await this.#repositoryRoot(git, path);
+		if (base === void 0) throw new RepositorySetupError("nothing-to-clean", "A plain checkout needs the base branch to return to.");
 		const head = await this.#run(git, [
 			"symbolic-ref",
 			"--quiet",
 			"--short",
 			"HEAD"
 		], root);
-		const branch = head.exitCode === 0 ? head.stdout.trim() : "";
-		if (branch.length === 0 || branch === base) throw new RepositorySetupError("nothing-to-clean", "The checkout is already on the base branch.");
+		const current = head.exitCode === 0 ? head.stdout.trim() : "";
+		if (current.length === 0 || current === base) {
+			if (named === void 0 || named === base) throw new RepositorySetupError("nothing-to-clean", "The checkout is already on the base branch.");
+			if (requirePushed) await this.#requirePushed(git, root, named);
+			await this.#run(git, [
+				"branch",
+				"-D",
+				"--",
+				named
+			], root).catch(() => void 0);
+			await this.#run(git, ["pull", "--ff-only"], root, GIT_FETCH_TIMEOUT_MS).catch(() => void 0);
+			return {
+				mode: "checkout",
+				root,
+				branch: named
+			};
+		}
+		if (requirePushed) await this.#requirePushed(git, root, current);
 		if ((await this.#run(git, [
 			"switch",
 			"--",
@@ -5389,13 +5488,13 @@ var RepositorySetupService = class {
 			"branch",
 			"-D",
 			"--",
-			branch
+			current
 		], root).catch(() => void 0);
 		await this.#run(git, ["pull", "--ff-only"], root, GIT_FETCH_TIMEOUT_MS).catch(() => void 0);
 		return {
 			mode: "checkout",
 			root,
-			branch
+			branch: current
 		};
 	}
 	bindLease(leaseId, sessionId) {
@@ -5672,6 +5771,17 @@ var RepositorySetupService = class {
 		}
 		return `${prefix}/${slug(baseBranch, "branch")}-${stamp}-${suffix}`;
 	}
+	/** Refuse to delete a branch holding commits no remote has. */
+	async #requirePushed(git, root, branch) {
+		const count = await this.#run(git, [
+			"rev-list",
+			"--count",
+			branch,
+			"--not",
+			"--remotes"
+		], root);
+		if (count.exitCode !== 0 || Number(count.stdout.trim()) > 0) throw new RepositorySetupError("unpushed-commits", "The branch has commits that are not on any remote; push or discard them first.");
+	}
 	async #repositoryRoot(git, cwd) {
 		const result = await this.#run(git, [
 			"rev-parse",
@@ -5910,6 +6020,7 @@ var RepositoryActionService = class {
 			const merged = await this.#run(gh, [
 				"pr",
 				"merge",
+				...request.pullNumber === void 0 ? [] : [String(request.pullNumber)],
 				`--${method}`,
 				...request.admin === true ? ["--admin"] : []
 			], before.root, REMOTE_TIMEOUT_MS);
@@ -6385,8 +6496,10 @@ function registerRepositorySetupRoute(ctx, service, sweep, cleaned) {
 					if (io.method !== "POST") return json(res, 405, { error: "method not allowed" });
 					const input = await readJson$6(io);
 					const path = string$2(input, "path");
-					const result = await service.cleanupMerged(path, string$2(input, "baseBranch"));
-					cleaned?.(path);
+					const branch = typeof input.branch === "string" && input.branch.length > 0 ? input.branch : void 0;
+					const baseBranch = typeof input.baseBranch === "string" && input.baseBranch.length > 0 ? input.baseBranch : void 0;
+					const result = await service.cleanupMerged(path, baseBranch, branch, input.requirePushed === true);
+					cleaned?.(path, branch);
 					return json(res, 200, result);
 				}
 				if (pathname === `/plugins/dsh-claude/repository/setup/sweep`) {
@@ -6490,6 +6603,9 @@ function actionRequest(input) {
 		...input.admin === void 0 ? {} : typeof input.admin === "boolean" ? { admin: input.admin } : (() => {
 			throw new RepositoryActionError("invalid-request", "The admin field must be a boolean.");
 		})(),
+		...input.pullNumber === void 0 ? {} : Number.isSafeInteger(input.pullNumber) && input.pullNumber > 0 ? { pullNumber: input.pullNumber } : (() => {
+			throw new RepositoryActionError("invalid-request", "The pullNumber field must be a positive integer.");
+		})(),
 		...input.mergeMethod === void 0 ? {} : input.mergeMethod === "merge" || input.mergeMethod === "squash" || input.mergeMethod === "rebase" ? { mergeMethod: input.mergeMethod } : (() => {
 			throw new RepositoryActionError("invalid-request", "The mergeMethod field is invalid.");
 		})()
@@ -8522,30 +8638,121 @@ const FILE_TOOLS = /* @__PURE__ */ new Set([
 	"NotebookEdit"
 ]);
 /** The activity detail is a redacted JSON string that may be cut short, so
-*  this matches the one key rather than parsing the document. */
+*  these match one key each rather than parsing the document. */
 const PATH_KEY = /"(?:file_path|notebook_path)"\s*:\s*"((?:[^"\\]|\\.)*)"/u;
-/** Absolute paths Claude wrote through its file tools, first-seen order. */
+const COMMAND_KEY = /"command"\s*:\s*"((?:[^"\\]|\\.)*)"/u;
+/** An absolute path token in shell text: not the tail of a URL, a relative
+*  path, a `$VAR` or a `NAME=` assignment, and not reaching into quotes or
+*  shell punctuation. */
+const PATH_TOKEN = String.raw`\/[\w.@+~-]+(?:\/[\w.@+~-]+)*`;
+/** Where a command goes to work or writes: the shell forms Claude actually
+*  uses under full access. Reading a path (grep, cat, ls) is not touching it. */
+const WRITE_CONTEXTS = [
+	new RegExp(String.raw`(?:^|[;&|(]\s*)(?:cd|pushd)\s+(${PATH_TOKEN})`, "gmu"),
+	new RegExp(String.raw`\bgit\s+-C\s+(${PATH_TOKEN})`, "gu"),
+	new RegExp(String.raw`\bgit\s+worktree\s+add\s+(?:-\S+\s+)*(${PATH_TOKEN})`, "gu"),
+	new RegExp(String.raw`>{1,2}\s*(${PATH_TOKEN})`, "gu"),
+	new RegExp(String.raw`\btee\s+(?:-\S+\s+)*(${PATH_TOKEN})`, "gu"),
+	new RegExp(String.raw`\bmkdir\s+(?:-\S+\s+)*(${PATH_TOKEN})`, "gu"),
+	new RegExp(String.raw`\bsed\s+-i\S*\s+(?:(?:'[^']*'|"[^"]*"|\S+)\s+)+?(${PATH_TOKEN})`, "gu"),
+	new RegExp(String.raw`\b(?:cp|mv|install)\s+(?:\S+\s+)+?(${PATH_TOKEN})`, "gu"),
+	new RegExp(String.raw`\bopen\(\s*['"](${PATH_TOKEN})['"]\s*,\s*['"][wa]`, "gu")
+];
+/** A pathological command (a generated file list) must not turn into a
+*  hundred git probes. */
+const MAX_PATHS_PER_COMMAND = 50;
+const PULL_REQUEST_URL = /https:\/\/github\.com\/([\w.-]+\/[\w.-]+)\/pull\/(\d{1,9})(?![\d])/gu;
+const MAX_PULL_REQUESTS = 8;
+function unescaped(escaped) {
+	try {
+		return JSON.parse(`"${escaped}"`);
+	} catch {
+		return;
+	}
+}
+/** Absolute paths Claude worked in or wrote to, first-seen order: the file
+*  tools' own argument, plus the paths a Bash command changes into, sets a
+*  worktree up at, or writes -- under full access Claude edits through
+*  heredocs and sed. Paths outside any repository are dropped downstream. */
 function touchedFilePaths(activities) {
 	const paths = /* @__PURE__ */ new Set();
 	for (const activity of activities) {
-		if (activity.kind !== "tool-call" && activity.kind !== "subagent" || activity.toolName === void 0 || !FILE_TOOLS.has(activity.toolName) || activity.detail === void 0) continue;
-		const escaped = PATH_KEY.exec(activity.detail)?.[1];
-		if (escaped === void 0) continue;
-		try {
-			const path = JSON.parse(`"${escaped}"`);
-			if (isAbsolute(path)) paths.add(path);
-		} catch {}
+		if (activity.kind !== "tool-call" && activity.kind !== "subagent" || activity.toolName === void 0 || activity.detail === void 0) continue;
+		if (FILE_TOOLS.has(activity.toolName)) {
+			const escaped = PATH_KEY.exec(activity.detail)?.[1];
+			const path = escaped === void 0 ? void 0 : unescaped(escaped);
+			if (path !== void 0 && isAbsolute(path)) paths.add(path);
+		} else if (activity.toolName === "Bash") {
+			const escaped = COMMAND_KEY.exec(activity.detail)?.[1];
+			const command = escaped === void 0 ? void 0 : unescaped(escaped);
+			if (command === void 0) continue;
+			const found = [];
+			for (const context of WRITE_CONTEXTS) for (const match of command.matchAll(context)) {
+				const path = match[1];
+				if (path !== void 0 && !path.startsWith("/dev/")) found.push({
+					index: match.index + match[0].length - path.length,
+					path
+				});
+			}
+			found.sort((left, right) => left.index - right.index);
+			for (const { path } of found.slice(0, MAX_PATHS_PER_COMMAND)) paths.add(path);
+		}
 	}
 	return [...paths];
 }
+const PR_CREATE = /\bgh\s+pr\s+create\b/u;
+/** The pull requests the session opened: the URL `gh pr create` printed,
+*  read off that call's own result. Other than the session repository's,
+*  once each in first-seen order. A URL merely read, quoted or mentioned
+*  (a fixture, a summary, a `gh pr view`) is not one the session made.
+*  A checkout that has since moved back to its base branch no longer knows
+*  about its pull request; the log still does. */
+function touchedPullRequests(activities, ownRepository) {
+	const found = /* @__PURE__ */ new Map();
+	const own = ownRepository?.toLowerCase();
+	const creating = /* @__PURE__ */ new Set();
+	for (const activity of activities) {
+		if (activity.toolUseId === void 0) continue;
+		if (activity.kind === "tool-call" || activity.kind === "subagent" && activity.toolName !== void 0) {
+			if (activity.toolName !== "Bash" || activity.detail === void 0) continue;
+			const escaped = COMMAND_KEY.exec(activity.detail)?.[1];
+			const command = escaped === void 0 ? void 0 : unescaped(escaped);
+			if (command !== void 0 && PR_CREATE.test(command)) creating.add(activity.toolUseId);
+			continue;
+		}
+		if (activity.detail === void 0 || !creating.has(activity.toolUseId)) continue;
+		for (const match of activity.detail.matchAll(PULL_REQUEST_URL)) {
+			const repository = match[1]?.toLowerCase();
+			const number = Number(match[2]);
+			if (repository === void 0 || repository === own || !Number.isSafeInteger(number) || number <= 0) continue;
+			const key = `${repository}#${number}`;
+			if (found.has(key)) continue;
+			found.set(key, {
+				repository,
+				number
+			});
+			if (found.size >= MAX_PULL_REQUESTS) return [...found.values()];
+		}
+	}
+	return [...found.values()];
+}
+async function isDirectory(path) {
+	try {
+		return (await stat(path)).isDirectory();
+	} catch {
+		return false;
+	}
+}
 /** Repository roots behind the touched paths, minus the session's own, in
 *  first-seen order. `rootOf` answers undefined outside any repository. */
-async function touchedRepositoryRoots(paths, sessionRoot, rootOf, max) {
+async function touchedRepositoryRoots(paths, sessionRoot, rootOf, max, directory = isDirectory) {
 	const roots = [];
-	const directories = new Set(paths.map((path) => dirname(path)));
+	const directories = /* @__PURE__ */ new Set();
+	for (const path of paths) directories.add(await directory(path) ? path : dirname(path));
 	for (const directory of directories) {
 		const root = await rootOf(directory);
 		if (root === void 0 || root === sessionRoot || roots.includes(root)) continue;
+		if (sessionRoot.startsWith(root.endsWith(sep) ? root : root + sep)) continue;
 		roots.push(root);
 		if (roots.length >= max) break;
 	}
@@ -8553,13 +8760,52 @@ async function touchedRepositoryRoots(paths, sessionRoot, rootOf, max) {
 }
 /** Whether a linked checkout still has anything to show. A cleaned-up
 *  worktree is gone, and a checkout cleaned up in place is back on base with
-*  nothing pending -- either way its bar comes down. A clean checkout with an
-*  open or merged pull request, or unpushed work, stays. */
+*  nothing pending -- either way its bar comes down. A checkout with an open
+*  or merged pull request, or unpushed commits, stays. A clean branch with no
+*  upstream is what a tool checkout looks like and is no evidence on its own. */
 function linkedRepositoryShown(status) {
 	if (status.status !== "ready") return false;
-	return status.dirty === true || status.upstream === false || (status.ahead ?? 0) > 0 || status.pullRequest !== void 0;
+	return status.dirty === true || (status.ahead ?? 0) > 0 || status.pullRequest !== void 0;
 }
 //#endregion
+//#region src/session-root-ledger.ts
+/** Which extra checkout roots a session's routes may act on.
+*
+*  A session's linked repositories are re-derived on every projection sweep,
+*  and any one sweep's git/gh probes can transiently fail -- dropping a
+*  checkout the client is still showing a bar for. Replacing the authorised
+*  set each sweep would then 409 that bar's controls until the next good
+*  sweep, which reads as a control that silently does nothing. A session only
+*  ever gains checkouts it has genuinely written into, so the ledger only
+*  grows within a session's lifetime and never un-vouches a root a later
+*  probe happened to miss. Bounded so a long session cannot grow it forever. */
+var SessionRootLedger = class {
+	#roots = /* @__PURE__ */ new Map();
+	#max;
+	constructor(max) {
+		this.#max = max;
+	}
+	/** Add the roots this sweep vouched for; existing ones stay. */
+	vouch(sessionId, roots) {
+		let set = this.#roots.get(sessionId);
+		if (set === void 0) {
+			set = /* @__PURE__ */ new Set();
+			this.#roots.set(sessionId, set);
+		}
+		for (const root of roots) {
+			set.delete(root);
+			set.add(root);
+			if (set.size > this.#max) set.delete(set.values().next().value);
+		}
+	}
+	allows(sessionId, root) {
+		return this.#roots.get(sessionId)?.has(root) === true;
+	}
+	forget(sessionId) {
+		this.#roots.delete(sessionId);
+	}
+};
+//#endregion
 //#region src/update-routes.ts
 const PLUGIN_PACKAGE_NAME = "@norman-else/dsh-claude";
 const MAX_MANIFEST_BYTES = 262144;
@@ -9569,28 +9815,52 @@ async function apply(ctx, config) {
 				supervisor.limitsChanged();
 			}
 		});
-		registerRepositorySetupRoute(webCtx, repositorySetup, () => sweepWorktrees?.(), (path) => repositoryStatus.invalidate(path));
+		/** Linked pull requests cleaned up, as `clone root + branch`: the log
+		*  still names them, so the sweep has to be told to stop listing them. */
+		const cleanedLinked = /* @__PURE__ */ new Set();
+		registerRepositorySetupRoute(webCtx, repositorySetup, () => sweepWorktrees?.(), (path, branch) => {
+			repositoryStatus.invalidate(path);
+			if (branch !== void 0) cleanedLinked.add(`${path}\0${branch}`);
+		});
 		registerRepositoryStatusRoute(webCtx, repositoryStatus);
 		registerRepositoryFileRoute(webCtx, repositoryStatus);
 		registerJiraRoute(webCtx, new JiraService());
 		const repositoryActions = new RepositoryActionService(subprocess, supervisorConfig.executablePath, (cwd) => repositoryStatus.invalidate(cwd));
-		/** Roots the latest projection probe vouched for, per session: the only
-		*  checkouts a route may act on besides the session's own. */
-		const extraRoots = /* @__PURE__ */ new Map();
+		/** Checkouts besides its own a session's routes may act on: every root a
+		*  projection sweep has ever vouched for, so a transient probe failure in
+		*  one sweep does not un-authorise a linked bar the client still shows. */
+		const extraRoots = new SessionRootLedger(32);
 		const cwdForClaudeSession = (sessionId, root) => {
 			const agent = webCtx.agents.get(sessionId);
 			if (agent === void 0 || webCtx.agentPresets.composedPreset(agent.ctx) !== "claude") return void 0;
 			if (root === void 0) return agent.session.header.cwd;
-			return extraRoots.get(sessionId)?.includes(root) === true ? root : void 0;
+			return extraRoots.allows(sessionId, root) ? root : void 0;
 		};
 		const extraRepositoriesForClaudeSession = async (sessionId, activities) => {
 			const cwd = cwdForClaudeSession(sessionId);
 			if (cwd === void 0) return [];
-			const own = await repositoryStatus.rootOf(cwd);
+			const [own, ownStatus] = await Promise.all([repositoryStatus.rootOf(cwd), repositoryStatus.inspect(cwd)]);
 			const roots = await touchedRepositoryRoots(touchedFilePaths(activities), own ?? cwd, (directory) => repositoryStatus.rootOf(directory), MAX_EXTRA_REPOSITORIES);
-			const statuses = (await Promise.all(roots.map((root) => repositoryStatus.inspect(root)))).filter(linkedRepositoryShown);
-			extraRoots.set(sessionId, statuses.map((status) => status.root ?? status.cwd));
-			return statuses;
+			const probed = await Promise.all(roots.map((root) => repositoryStatus.inspect(root)));
+			const checkouts = probed.filter(linkedRepositoryShown);
+			const covered = new Set(checkouts.map((status) => `${status.remote?.toLowerCase()}#${status.pullRequest?.number}`));
+			const pullRequests = touchedPullRequests(activities, ownStatus.remote).filter((item) => !covered.has(`${item.repository}#${item.number}`)).slice(0, Math.max(0, MAX_EXTRA_REPOSITORIES - checkouts.length));
+			const detached = (await Promise.all(pullRequests.map(async (item) => {
+				const clone = probed.find((status) => status.status === "ready" && status.remote?.toLowerCase() === item.repository && status.root !== void 0);
+				const status = await repositoryStatus.inspectPullRequest(clone?.root ?? cwd, item.repository, item.number);
+				if (clone?.root === void 0 || status.status !== "ready") return status;
+				if (status.branch !== void 0 && cleanedLinked.has(`${clone.root}\0${status.branch}`)) return {
+					status: "unavailable",
+					cwd
+				};
+				return {
+					...status,
+					root: clone.root
+				};
+			}))).filter(linkedRepositoryShown);
+			const linked = [...checkouts, ...detached];
+			extraRoots.vouch(sessionId, linked.flatMap((status) => status.root === void 0 ? [] : [status.root]));
+			return linked;
 		};
 		registerRepositoryActionRoute(webCtx, repositoryActions, cwdForClaudeSession);
 		registerClaudePromptsRoute(webCtx);