@norman-else/dsh-claude 0.1.46 → 0.1.48

package/lib/index.mjs

@@ -1,6 +1,6 @@
-import { A as CLAUDE_REPOSITORY_FEEDBACK_PATH, B as DEFAULT_CLAUDE_RENDER_MODE, C as CLAUDE_PROJECTION_PATH, D as CLAUDE_PROSE_MODES, E as CLAUDE_PROMPT_REFINE_PATH, F as CLAUDE_REWIND_PATH, G as isClaudeRenderMode, H as TASK_TOOL_NAMES, I as CLAUDE_UPDATE_CHECK_PATH, L as CLAUDE_UPDATE_PATH, M as CLAUDE_REPOSITORY_SETUP_PATH, N as CLAUDE_REPOSITORY_STATUS_PATH, O as CLAUDE_RENDER_MODES, P as CLAUDE_REVIEW_COMMENT_PATH, R as CLAUDE_USAGE_PATH, S as CLAUDE_PLAN_FEEDBACK_PATH, T as CLAUDE_PROMPT_NAME_PATH, U as isClaudeAlertMode, W as isClaudeProseMode, _ as CLAUDE_CODE_PROVIDER_IDS, a as latestClaudeTasks, b as CLAUDE_GLOBAL_SETTINGS_PATH, c as normalizeTasksEvent, d as CLAUDE_ACTIVITY_EVENT, f as CLAUDE_ALERT_MODES, g as CLAUDE_CODE_PROVIDER, h as CLAUDE_CODE_PRESET_ID, i as latestClaudeSessionBinding, j as CLAUDE_REPOSITORY_FILE_PATH, k as CLAUDE_REPOSITORY_ACTION_PATH, l as redactText, m as CLAUDE_CLIENT_DIAGNOSTICS_PATH, n as currentClaudeActivityCursor, o as normalizeActivity, p as CLAUDE_ASK_PATH, r as latestClaudeContextUsage, s as normalizeContextUsage, t as boundText, u as safeDetail, v as CLAUDE_DOCTOR_PATH, w as CLAUDE_PROMPTS_PATH, x as CLAUDE_JIRA_PATH, y as CLAUDE_EDITOR_OPEN_PATH, z as DEFAULT_CLAUDE_PROSE_MODE } from "./events-oovRTmX7.mjs";
-import { a as projectClaudeCommands, i as CLAUDE_COMMANDS_SERVICE, r as dynamicPresenterDefinition, t as CLAUDE_PRESENTER_NAMES } from "./presenters-BVWj7u0a.mjs";
-import { a as resolveClaudeExecutable, n as ensureManagedPreset, o as runClaudeDoctor, t as ManagedPresetConflictError } from "./preset-installer-CuosP3sA.mjs";
+import { A as CLAUDE_REPOSITORY_FILE_PATH, C as CLAUDE_PROMPTS_PATH, D as CLAUDE_RENDER_MODES, E as CLAUDE_PROSE_MODES, F as CLAUDE_UPDATE_CHECK_PATH, H as isClaudeAlertMode, I as CLAUDE_UPDATE_PATH, L as CLAUDE_USAGE_PATH, M as CLAUDE_REPOSITORY_STATUS_PATH, N as CLAUDE_REVIEW_COMMENT_PATH, O as CLAUDE_REPOSITORY_ACTION_PATH, P as CLAUDE_REWIND_PATH, R as DEFAULT_CLAUDE_PROSE_MODE, S as CLAUDE_PROJECTION_PATH, T as CLAUDE_PROMPT_REFINE_PATH, U as isClaudeProseMode, V as TASK_TOOL_NAMES, W as isClaudeRenderMode, _ as CLAUDE_CODE_PROVIDER_IDS, a as latestClaudeTasks, b as CLAUDE_JIRA_PATH, c as normalizeTasksEvent, d as CLAUDE_ACTIVITY_EVENT, f as CLAUDE_ALERT_MODES, g as CLAUDE_CODE_PROVIDER, h as CLAUDE_CODE_PRESET_ID, i as latestClaudeSessionBinding, j as CLAUDE_REPOSITORY_SETUP_PATH, k as CLAUDE_REPOSITORY_FEEDBACK_PATH, l as redactText, m as CLAUDE_CLIENT_DIAGNOSTICS_PATH, n as currentClaudeActivityCursor, o as normalizeActivity, p as CLAUDE_ASK_PATH, r as latestClaudeContextUsage, s as normalizeContextUsage, t as boundText, u as safeDetail, v as CLAUDE_DOCTOR_PATH, w as CLAUDE_PROMPT_NAME_PATH, x as CLAUDE_PLAN_FEEDBACK_PATH, y as CLAUDE_GLOBAL_SETTINGS_PATH, z as DEFAULT_CLAUDE_RENDER_MODE } from "./events-B498uofA.mjs";
+import { a as projectClaudeCommands, i as CLAUDE_COMMANDS_SERVICE, r as dynamicPresenterDefinition, t as CLAUDE_PRESENTER_NAMES } from "./presenters-CRFcjLSC.mjs";
+import { a as resolveClaudeExecutable, n as ensureManagedPreset, o as runClaudeDoctor, t as ManagedPresetConflictError } from "./preset-installer-C4TTNV9L.mjs";
 import z from "@deepseek-ai/schemastery";
 import { createHash, randomUUID } from "node:crypto";
 import { chmod, mkdir, opendir, readFile, readdir, realpath, rename, rm, stat, writeFile } from "node:fs/promises";
@@ -1810,7 +1810,7 @@ function createManagedClaudeSpawner(runtime, executablePath, observe) {
 *  honours `.gitignore`, so build output and `node_modules` are neither
 *  captured nor removed.
 */
-const MAX_OUTPUT_BYTES$5 = 65536;
+const MAX_OUTPUT_BYTES$4 = 65536;
 /** `add -A` walks the whole checkout; a large repository needs more than the
 *  status probes' five seconds, and this sits in front of every turn. */
 const GIT_TIMEOUT_MS$4 = 3e4;
@@ -1835,8 +1835,8 @@ async function run$1(runtime, git, args, cwd, env = {}) {
 		cwd,
 		stdio: {
 			stdin: "ignore",
-			stdout: { maxBytes: MAX_OUTPUT_BYTES$5 },
-			stderr: { maxBytes: MAX_OUTPUT_BYTES$5 }
+			stdout: { maxBytes: MAX_OUTPUT_BYTES$4 },
+			stderr: { maxBytes: MAX_OUTPUT_BYTES$4 }
 		},
 		graceMs: 1e3,
 		signal: AbortSignal.timeout(GIT_TIMEOUT_MS$4),
@@ -1923,6 +1923,18 @@ const CLAUDE_MODE_BY_SANDBOX = {
 	"workspace-write": "acceptEdits",
 	"danger-full-access": "bypassPermissions"
 };
+/** Appended to the Claude Code system prompt on every session.
+*
+*  The plan panel opens on exactly one signal: an `ExitPlanMode` call, whose
+*  argument is the plan (see `planText` in permission.ts). Claude Code's own
+*  plan mode says to make that call once the plan file is written, but
+*  user-installed skills routinely say the opposite — "confirm the design in
+*  prose before proceeding" — and a turn that ends on that question hands DSH
+*  nothing to show: no record, no button, no panel, until the user types
+*  "continue" and Claude makes the call it skipped. This line settles the
+*  conflict in favour of the handoff, so the plan reaches the panel the moment
+*  it is done rather than one message later. */
+const PLAN_MODE_HANDOFF_PROMPT = "When you are in plan mode and the plan is written, end the turn by calling ExitPlanMode with the plan. Do not end a plan-mode turn by asking the user for confirmation in prose: the user reads and approves the plan through ExitPlanMode, and a turn that stops short of that call shows them nothing.";
 /** Fold DSH's native access selector into Claude Code's closest permission mode. */
 function claudePermissionMode(events) {
 	for (let index = events.length - 1; index >= 0; index -= 1) {
@@ -2072,8 +2084,7 @@ var ClaudeSupervisor = class {
 			cwd: entry.cwd,
 			model: entry.model,
 			...entry.thinkingMode === void 0 ? {} : { thinkingMode: entry.thinkingMode },
-			lastUsedAt: entry.lastUsedAt,
-			...entry.process === void 0 ? {} : { pid: entry.process.handle.pid }
+			lastUsedAt: entry.lastUsedAt
 		}));
 	}
 	supportedCommands(agent, model = this.#config.defaultModel) {
@@ -2596,7 +2607,8 @@ var ClaudeSupervisor = class {
 			],
 			systemPrompt: {
 				type: "preset",
-				preset: "claude_code"
+				preset: "claude_code",
+				append: PLAN_MODE_HANDOFF_PROMPT
 			},
 			tools: {
 				type: "preset",
@@ -4198,7 +4210,7 @@ function registerClaudeDoctorRoutes(ctx, runtime, supervisor, config, resolution
 }
 //#endregion
 //#region src/projection-routes.ts
-const MAX_SESSION_ID_CHARS$7 = 1024;
+const MAX_SESSION_ID_CHARS$6 = 1024;
 /** Slow-moving metadata refresh and stream heartbeat cadence; deliberately off
 *  the transcript hot path so git/gh latency never delays visible text. */
 const META_REFRESH_MS = 5e3;
@@ -4206,7 +4218,7 @@ const META_REFRESH_MS = 5e3;
 *  so this cannot collide with one. */
 const MULTI_SEGMENT = "multi";
 function validSessionId(value) {
-	return value.length > 0 && value.length <= MAX_SESSION_ID_CHARS$7;
+	return value.length > 0 && value.length <= MAX_SESSION_ID_CHARS$6;
 }
 function targetFromUrl(url) {
 	const prefix = `${CLAUDE_PROJECTION_PATH}/`;
@@ -4536,15 +4548,22 @@ async function diffFuncnameArgs() {
 }
 //#endregion
 //#region src/repository-status.ts
-const MAX_OUTPUT_BYTES$4 = 65536;
+const MAX_OUTPUT_BYTES$3 = 65536;
+/** What the diff panel receives: whole files packed under this budget. */
 const MAX_DIFF_BYTES = 262144;
+/** What git may hand back before packing; beyond this the diff is truncated. */
+const MAX_RAW_DIFF_BYTES = 8388608;
+/** One file's share of the panel; a lockfile or bundle past this is elided by name. */
+const MAX_FILE_PATCH_BYTES = 65536;
 const MAX_FILE_BYTES = 8388608;
 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);
 }
@@ -4557,7 +4576,7 @@ async function collect$3(handle) {
 		lossy: stdout?.lossy === true
 	};
 }
-async function run(runtime, executable, args, cwd, timeoutMs, maxBytes = MAX_OUTPUT_BYTES$4) {
+async function run(runtime, executable, args, cwd, timeoutMs, maxBytes = MAX_OUTPUT_BYTES$3) {
 	const signal = AbortSignal.timeout(timeoutMs);
 	return collect$3(runtime.spawn({
 		argv: [executable, ...args],
@@ -4565,7 +4584,7 @@ async function run(runtime, executable, args, cwd, timeoutMs, maxBytes = MAX_OUT
 		stdio: {
 			stdin: "ignore",
 			stdout: { maxBytes },
-			stderr: { maxBytes: MAX_OUTPUT_BYTES$4 }
+			stderr: { maxBytes: MAX_OUTPUT_BYTES$3 }
 		},
 		graceMs: 1e3,
 		signal,
@@ -4644,6 +4663,31 @@ async function detectRepositoryOperation(gitDir) {
 		};
 	}
 }
+/**
+* Pack a unified diff into a byte budget one whole file at a time.
+*
+* A single oversized file (a lockfile, a bundle) used to void the entire
+* patch, which read as "no changes" in the panel. Files are kept in git's
+* order while they fit; a file past its own cap or past what is left of the
+* budget is skipped and named, so the panel still shows every other change.
+*/
+function packPatchByFile(patch, budget = MAX_DIFF_BYTES, perFile = MAX_FILE_PATCH_BYTES) {
+	let packed = "";
+	const elided = [];
+	for (const section of patch.split(/(?=^diff --git )/mu)) {
+		if (section.length === 0) continue;
+		if (section.length <= perFile && packed.length + section.length <= budget) {
+			packed += section;
+			continue;
+		}
+		const header = /^diff --git a\/(?<a>.*?) b\/(?<b>.*)$/mu.exec(section);
+		elided.push(header?.groups?.["b"] ?? header?.groups?.["a"] ?? "?");
+	}
+	return {
+		patch: packed,
+		elided
+	};
+}
 function parseDiffNumstat(value) {
 	let additions = 0;
 	let deletions = 0;
@@ -4719,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() } : {},
@@ -4759,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);
@@ -4956,19 +5070,20 @@ var RepositoryStatusService = class {
 				"--unified=3",
 				base,
 				"--"
-			], cwd, GIT_TIMEOUT_MS$3, MAX_DIFF_BYTES);
+			], cwd, GIT_TIMEOUT_MS$3, MAX_RAW_DIFF_BYTES);
 			if (patch.exitCode !== 0) return {
 				...summary,
 				truncated: true
 			};
 			const untracked = await this.#untrackedDiff(cwd, git, signal);
-			const combinedPatch = `${patch.stdout}${untracked.patch}`;
+			const packed = packPatchByFile(`${patch.stdout}${untracked.patch}`);
 			return {
 				additions: summary.additions + untracked.additions,
 				deletions: summary.deletions,
 				files: summary.files + untracked.files,
-				...patch.lossy ? {} : { patch: combinedPatch.slice(0, MAX_DIFF_BYTES) },
-				truncated: patch.lossy || untracked.truncated || combinedPatch.length > MAX_DIFF_BYTES
+				...patch.lossy ? {} : { patch: packed.patch },
+				...packed.elided.length === 0 ? {} : { elided: packed.elided },
+				truncated: patch.lossy || untracked.truncated
 			};
 		} catch {
 			return;
@@ -5037,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));
@@ -5132,7 +5247,7 @@ async function summarizeBranchSlug(executablePath, intent, factory = query) {
 }
 //#endregion
 //#region src/repository-setup.ts
-const MAX_OUTPUT_BYTES$3 = 131072;
+const MAX_OUTPUT_BYTES$2 = 131072;
 const GIT_TIMEOUT_MS$2 = 1e4;
 const GIT_FETCH_TIMEOUT_MS = 6e4;
 const MAX_PATH_CHARS$2 = 4096;
@@ -5295,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",
@@ -5307,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",
 			"--",
@@ -5346,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) {
@@ -5629,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",
@@ -5652,8 +5805,8 @@ var RepositorySetupService = class {
 			cwd,
 			stdio: {
 				stdin: "ignore",
-				stdout: { maxBytes: MAX_OUTPUT_BYTES$3 },
-				stderr: { maxBytes: MAX_OUTPUT_BYTES$3 }
+				stdout: { maxBytes: MAX_OUTPUT_BYTES$2 },
+				stderr: { maxBytes: MAX_OUTPUT_BYTES$2 }
 			},
 			graceMs: 1e3,
 			signal: AbortSignal.timeout(timeoutMs),
@@ -5694,7 +5847,7 @@ var RepositorySetupService = class {
 };
 //#endregion
 //#region src/repository-actions.ts
-const MAX_OUTPUT_BYTES$2 = 262144;
+const MAX_OUTPUT_BYTES$1 = 262144;
 const MAX_PATCH_CHARS = 65536;
 const MAX_MESSAGE_CHARS = 512;
 const MAX_PR_TEXT_CHARS = 8192;
@@ -5867,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);
@@ -6120,7 +6274,7 @@ var RepositoryActionService = class {
 				"--",
 				":(exclude)WARP.md",
 				":(exclude)**/WARP.md"
-			], root, GIT_TIMEOUT_MS$1, MAX_OUTPUT_BYTES$2),
+			], root, GIT_TIMEOUT_MS$1, MAX_OUTPUT_BYTES$1),
 			this.#run(git, [
 				...funcname,
 				"diff",
@@ -6130,7 +6284,7 @@ var RepositoryActionService = class {
 				"--",
 				":(exclude)WARP.md",
 				":(exclude)**/WARP.md"
-			], root, GIT_TIMEOUT_MS$1, MAX_OUTPUT_BYTES$2)
+			], root, GIT_TIMEOUT_MS$1, MAX_OUTPUT_BYTES$1)
 		]);
 		if (branchResult.exitCode !== 0) throw new RepositoryActionError("detached-head", "A detached HEAD cannot be committed from this panel.");
 		if (headResult.exitCode !== 0 || statusResult.exitCode !== 0 || statusResult.lossy) throw new RepositoryActionError("repository-unavailable", "Repository state is unavailable.");
@@ -6224,14 +6378,14 @@ var RepositoryActionService = class {
 		if (result.exitCode !== 0 || result.lossy) throw new RepositoryActionError(code, message);
 		return result;
 	}
-	#run(executable, args, cwd, timeoutMs, maxBytes = MAX_OUTPUT_BYTES$2) {
+	#run(executable, args, cwd, timeoutMs, maxBytes = MAX_OUTPUT_BYTES$1) {
 		return collect$1(this.#runtime.spawn({
 			argv: [executable, ...args],
 			cwd,
 			stdio: {
 				stdin: "ignore",
 				stdout: { maxBytes },
-				stderr: { maxBytes: MAX_OUTPUT_BYTES$2 }
+				stderr: { maxBytes: MAX_OUTPUT_BYTES$1 }
 			},
 			graceMs: 1e3,
 			signal: AbortSignal.timeout(timeoutMs),
@@ -6342,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`) {
@@ -6372,7 +6528,7 @@ function registerRepositorySetupRoute(ctx, service, sweep, cleaned) {
 //#endregion
 //#region src/repository-action-routes.ts
 const MAX_BODY_BYTES$6 = 16384;
-const MAX_SESSION_ID_CHARS$6 = 1024;
+const MAX_SESSION_ID_CHARS$5 = 1024;
 const MAX_ROOT_CHARS = 4096;
 const ACTIONS = /* @__PURE__ */ new Set([
 	"commit",
@@ -6409,7 +6565,7 @@ async function readJson$5(io) {
 }
 function sessionId$1(url) {
 	const value = url.searchParams.get("sessionId");
-	if (value === null || value.length === 0 || value.length > MAX_SESSION_ID_CHARS$6) throw new RepositoryActionError("invalid-session", "The session is invalid.");
+	if (value === null || value.length === 0 || value.length > MAX_SESSION_ID_CHARS$5) throw new RepositoryActionError("invalid-session", "The session is invalid.");
 	return value;
 }
 function requestedRoot(url) {
@@ -6447,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.");
 		})()
@@ -6528,187 +6687,6 @@ function registerRepositoryActionRoute(ctx, service, cwdForSession) {
 	});
 }
 //#endregion
-//#region src/editor-open.ts
-const MAX_OUTPUT_BYTES$1 = 8192;
-/** Long enough for a launcher shim to fail loudly, short enough that the
-*  request returns while the IDE is still booting. On Windows and Linux the
-*  IDE binary IS the launched process, so still running past this is success. */
-const SETTLE_MS = 1500;
-const EDITOR_IDS = /* @__PURE__ */ new Set(["cursor", "idea"]);
-/** Launch commands tried in order, first success wins. macOS keeps `open -a`
-*  behind the CLI shim because both shims are opt-in installs there, while
-*  `open -a` finds the bundle wherever Toolbox or the DMG dropped it. */
-const LAUNCHERS = {
-	cursor: {
-		darwin: [["cursor"], [
-			"open",
-			"-a",
-			"Cursor"
-		]],
-		win32: [["cursor"]],
-		linux: [["cursor"]]
-	},
-	idea: {
-		darwin: [
-			["idea"],
-			[
-				"open",
-				"-a",
-				"IntelliJ IDEA"
-			],
-			[
-				"open",
-				"-a",
-				"IntelliJ IDEA CE"
-			]
-		],
-		win32: [["idea"], ["idea64.exe"]],
-		linux: [["idea"], ["idea.sh"]]
-	}
-};
-/** cmd.exe re-interprets these, and a mis-parsed path opens the wrong project
-*  rather than failing. Refuse instead of guessing. */
-const WINDOWS_UNSAFE = /["&|<>^%]/u;
-var EditorOpenError = class extends Error {
-	code;
-	constructor(code, message) {
-		super(message);
-		this.name = "EditorOpenError";
-		this.code = code;
-	}
-};
-/** Open a session's working directory in a desktop editor. */
-var EditorOpenService = class {
-	#runtime;
-	#platform;
-	#settleMs;
-	constructor(runtime, platform = process.platform, settleMs = SETTLE_MS) {
-		this.#runtime = runtime;
-		this.#platform = platform;
-		this.#settleMs = settleMs;
-	}
-	async open(cwd, editor) {
-		if (this.#platform === "win32" && WINDOWS_UNSAFE.test(cwd)) throw new EditorOpenError("unsupported-path", "The project path cannot be opened through the Windows shell.");
-		const candidates = LAUNCHERS[editor][this.#platform] ?? LAUNCHERS[editor].linux ?? [];
-		let found = false;
-		for (const candidate of candidates) {
-			const argv = await this.#argv(candidate, cwd);
-			if (argv === void 0) continue;
-			found = true;
-			if (await this.#launch(argv, cwd)) return;
-		}
-		throw found ? new EditorOpenError("launch-failed", "The editor refused to open the project.") : new EditorOpenError("editor-unavailable", "The editor was not found on PATH.");
-	}
-	async #argv(candidate, cwd) {
-		const [program, ...rest] = candidate;
-		if (program === void 0) return void 0;
-		if (this.#platform === "win32") return [
-			"cmd.exe",
-			"/d",
-			"/s",
-			"/c",
-			program,
-			...rest,
-			cwd
-		];
-		try {
-			return [
-				await this.#runtime.resolveExecutable(program),
-				...rest,
-				cwd
-			];
-		} catch {
-			return;
-		}
-	}
-	/** True once the editor is launched: either the shim exited cleanly or the
-	*  process is still alive past the settle window. */
-	async #launch(argv, cwd) {
-		let handle;
-		try {
-			handle = this.#runtime.spawn({
-				argv,
-				cwd,
-				stdio: {
-					stdin: "ignore",
-					stdout: { maxBytes: MAX_OUTPUT_BYTES$1 },
-					stderr: { maxBytes: MAX_OUTPUT_BYTES$1 }
-				},
-				graceMs: 1e3,
-				env: {}
-			});
-		} catch {
-			return false;
-		}
-		return await Promise.race([handle.done.then((outcome) => outcome.exitCode === 0), new Promise((resolve) => {
-			setTimeout(() => resolve(true), this.#settleMs).unref?.();
-		})]);
-	}
-};
-//#endregion
-//#region src/editor-open-routes.ts
-const MAX_SESSION_ID_CHARS$5 = 1024;
-/** Open the session's working directory in a desktop editor. Query-only: the
-*  request carries two enum-ish values, so there is no body to parse. */
-function registerEditorOpenRoute(ctx, service, cwdForSession) {
-	registerPluginRoute(ctx, {
-		mode: "unary",
-		kind: "exact",
-		path: CLAUDE_EDITOR_OPEN_PATH,
-		methods: ["POST"],
-		budget: "fast",
-		handler: async (io) => {
-			const params = io.url.searchParams;
-			const id = params.get("sessionId");
-			const editor = params.get("editor");
-			if (id === null || id.length === 0 || id.length > MAX_SESSION_ID_CHARS$5) return {
-				status: 400,
-				value: {
-					error: "invalid-session",
-					message: "The session is invalid."
-				}
-			};
-			if (editor === null || !EDITOR_IDS.has(editor)) return {
-				status: 400,
-				value: {
-					error: "invalid-editor",
-					message: "The editor is invalid."
-				}
-			};
-			const cwd = cwdForSession(id);
-			if (cwd === void 0) return {
-				status: 409,
-				value: {
-					error: "session-unavailable",
-					message: "The Claude session is unavailable."
-				}
-			};
-			try {
-				await service.open(cwd, editor);
-				return {
-					status: 200,
-					value: { opened: true }
-				};
-			} catch (error) {
-				if (error instanceof EditorOpenError) return {
-					status: 409,
-					value: {
-						error: error.code,
-						message: error.message
-					}
-				};
-				return {
-					status: 500,
-					value: {
-						error: "editor-open-unavailable",
-						message: "The editor could not be launched."
-					}
-				};
-			}
-		}
-	});
-}
-//#endregion
 //#region src/prompts.ts
 const MAX_PROMPT_FILES = 256;
 const MAX_PROMPT_BYTES = 16384;
@@ -8660,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;
 	}
@@ -8691,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;
@@ -8967,6 +9075,54 @@ function registerClaudeUpdateRoutes(ctx, runtime, deps = {}) {
 	});
 }
 //#endregion
+//#region src/windows-job-runner.ts
+const RUN_AS_NODE = "ELECTRON_RUN_AS_NODE";
+/**
+* Make the Host's Windows Job runner start as Node when the Host itself is an
+* Electron utility process.
+*
+* Since DSH Desktop 2.0.7 the Host runs in `utilityProcess.fork` and, on
+* Windows, `subprocess-local` launches every ordinary target through a helper
+* it spawns as `[process.execPath, runner.js]`. Inside Electron that path is
+* `DSH Desktop.exe`, and the fork carries no `ELECTRON_RUN_AS_NODE`, so the
+* helper starts as a second GUI instance, yields to the running one, and exits
+* 0 without ever reporting -- the Host then fails the spawn with "Windows Job
+* runner exited with exit code 0 before proving its managed range empty".
+*
+* The runner's environment is read from `process.env` synchronously inside
+* `spawn()`, so the flag is set for exactly that call and removed after. The
+* target's own environment is built the same way, so the spec tells the Host
+* to drop the flag there: a target must not inherit a variable that turns any
+* Electron app it launches into a bare Node process.
+*/
+function withElectronNodeRunner(runtime, options = {}) {
+	const platform = options.platform ?? process.platform;
+	const electron = options.electron ?? process.versions.electron !== void 0;
+	if (platform !== "win32" || !electron) return runtime;
+	return new Proxy(runtime, { get(target, property, receiver) {
+		if (property !== "spawn") {
+			const value = Reflect.get(target, property, receiver);
+			return typeof value === "function" ? value.bind(target) : value;
+		}
+		return (spec) => {
+			const withoutFlag = {
+				...spec,
+				env: {
+					...spec.env,
+					[RUN_AS_NODE]: void 0
+				}
+			};
+			if (process.env[RUN_AS_NODE] !== void 0) return target.spawn(withoutFlag);
+			process.env[RUN_AS_NODE] = "1";
+			try {
+				return target.spawn(withoutFlag);
+			} finally {
+				delete process.env[RUN_AS_NODE];
+			}
+		};
+	} });
+}
+//#endregion
 //#region src/plan-usage-routes.ts
 const EMPTY = {
 	available: false,
@@ -9514,6 +9670,7 @@ async function installManagedPresetCompatibility(logger, install = ensureManaged
 	}
 }
 async function apply(ctx, config) {
+	const subprocess = withElectronNodeRunner(ctx.subprocess);
 	await installManagedPresetCompatibility(ctx.logger);
 	const defaultLimits = {
 		idleTimeoutMs: config.idleTimeoutMs ?? 18e5,
@@ -9531,15 +9688,15 @@ async function apply(ctx, config) {
 	};
 	await applySettingsOverrides();
 	const sidecar = new ClaudeSidecarRepository();
-	const repositoryStatus = new RepositoryStatusService(ctx.subprocess);
-	const repositorySetup = new RepositorySetupService(ctx.subprocess, {
+	const repositoryStatus = new RepositoryStatusService(subprocess);
+	const repositorySetup = new RepositorySetupService(subprocess, {
 		branchPrefix: () => readWorktreeBranchPrefix(),
 		summarizeBranch: (intent) => summarizeBranchSlug(supervisorConfig.executablePath, intent)
 	});
 	const reviewComments = new ReviewCommentStore();
 	const commandCatalogs = /* @__PURE__ */ new Map();
 	const supervisor = new ClaudeSupervisor({
-		runtime: ctx.subprocess,
+		runtime: subprocess,
 		approval: ctx.approval,
 		userQuestions: ctx.userQuestions,
 		config: supervisorConfig,
@@ -9548,7 +9705,7 @@ async function apply(ctx, config) {
 	});
 	let resolutionError;
 	try {
-		supervisorConfig.executablePath = (await resolveClaudeExecutable(ctx.subprocess, config.executablePath === void 0 || config.executablePath.length === 0 ? void 0 : config.executablePath)).path;
+		supervisorConfig.executablePath = (await resolveClaudeExecutable(subprocess, config.executablePath === void 0 || config.executablePath.length === 0 ? void 0 : config.executablePath)).path;
 		ctx.llm.registerAdapter([...CLAUDE_CODE_PROVIDER_IDS], createClaudeCodeAdapter(supervisor, ctx.agents, ctx.attachments, (agent) => ctx.agentPresets.composedPreset(agent.ctx), (sessionId) => reviewComments.drain(sessionId), () => readRenderMode(), (request) => summarizeSessionTitle(supervisorConfig.executablePath, request), () => probeClaudeModels(supervisorConfig.executablePath)));
 		ctx.effect(() => {
 			const mounted = /* @__PURE__ */ new Map();
@@ -9648,9 +9805,9 @@ async function apply(ctx, config) {
 	ctx.effect(() => () => repositoryStatus.dispose(), "dsh-claude: repository status cache");
 	ctx.inject(["webServer"], (webCtx) => {
 		registerClaudeClientDiagnosticsRoute(webCtx);
-		registerClaudeDoctorRoutes(webCtx, webCtx.subprocess, supervisor, supervisorConfig, resolutionError);
+		registerClaudeDoctorRoutes(webCtx, subprocess, supervisor, supervisorConfig, resolutionError);
 		const desktopActions = webCtx.get("desktopActions");
-		registerClaudeUpdateRoutes(webCtx, webCtx.subprocess, { ...typeof desktopActions?.requestRestart === "function" ? { requestRestart: desktopActions.requestRestart.bind(desktopActions) } : {} });
+		registerClaudeUpdateRoutes(webCtx, subprocess, { ...typeof desktopActions?.requestRestart === "function" ? { requestRestart: desktopActions.requestRestart.bind(desktopActions) } : {} });
 		registerClaudeGlobalSettingsRoute(webCtx, {
 			defaultLimits,
 			onUpdated: async () => {
@@ -9658,37 +9815,60 @@ 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(webCtx.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();
+		const repositoryActions = new RepositoryActionService(subprocess, supervisorConfig.executablePath, (cwd) => repositoryStatus.invalidate(cwd));
+		/** 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);
-		registerEditorOpenRoute(webCtx, new EditorOpenService(webCtx.subprocess), cwdForClaudeSession);
 		registerClaudePromptsRoute(webCtx);
-		const promptAssist = new PromptAssistService(webCtx.subprocess, () => supervisorConfig.executablePath);
+		const promptAssist = new PromptAssistService(subprocess, () => supervisorConfig.executablePath);
 		registerClaudePromptNameRoute(webCtx, promptAssist);
 		registerClaudePromptRefineRoute(webCtx, promptAssist);
-		registerPullRequestFeedbackRoute(webCtx, new PullRequestFeedbackService(webCtx.subprocess), cwdForClaudeSession);
-		registerAskRoute(webCtx, new AskService(webCtx.subprocess, supervisorConfig.executablePath), cwdForClaudeSession, (sessionId) => {
+		registerPullRequestFeedbackRoute(webCtx, new PullRequestFeedbackService(subprocess), cwdForClaudeSession);
+		registerAskRoute(webCtx, new AskService(subprocess, supervisorConfig.executablePath), cwdForClaudeSession, (sessionId) => {
 			const snapshot = supervisor.snapshots().find((item) => item.sessionId === sessionId);
 			return snapshot === void 0 ? void 0 : {
 				model: claudeModelValue(snapshot.model),
@@ -9710,7 +9890,7 @@ async function apply(ctx, config) {
 			reset: (sessionId) => supervisor.disposeSession(sessionId),
 			restoreFiles: async (sessionId, tree) => {
 				const cwd = webCtx.agents.get(sessionId)?.session.header.cwd;
-				return cwd === void 0 ? false : restoreWorktreeTree(ctx.subprocess, cwd, tree);
+				return cwd === void 0 ? false : restoreWorktreeTree(subprocess, cwd, tree);
 			}
 		});
 		registerPlanUsageRoute(webCtx, (fetchedAt) => probePlanUsage(supervisorConfig.executablePath, fetchedAt));