@gilbertgt/dsh-plan-orchestrator 1.0.0

package/lib/client.js

@@ -0,0 +1,1242 @@
+window.__ModuleLoader__.load({
+	id: "@gilbertgt/dsh-plan-orchestrator",
+	factory: (require) => {
+		var module = { exports: {} };
+		var exports = module.exports;
+		Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+		//#region \0rolldown/runtime.js
+		var __create = Object.create;
+		var __defProp = Object.defineProperty;
+		var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+		var __getOwnPropNames = Object.getOwnPropertyNames;
+		var __getProtoOf = Object.getPrototypeOf;
+		var __hasOwnProp = Object.prototype.hasOwnProperty;
+		var __copyProps = (to, from, except, desc) => {
+			if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+				key = keys[i];
+				if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+			return to;
+		};
+		var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+			value: mod,
+			enumerable: true
+		}) : target, mod));
+		//#endregion
+		let react = require("react");
+		react = __toESM(react, 1);
+		let react_jsx_runtime = require("react/jsx-runtime");
+		//#region src/client/locales.ts
+		const zh = {
+			nav: "Plan Mode",
+			overview: "總覽",
+			roles: "角色模型",
+			planning: "規劃",
+			execution: "執行",
+			review: "審查",
+			recovery: "恢復",
+			external: "External Issue",
+			diagnostics: "進階／診斷",
+			loading: "載入中…",
+			save: "儲存",
+			stop: "停止",
+			resume: "安全恢復"
+		};
+		const en = {
+			nav: "Plan Mode",
+			overview: "Overview",
+			roles: "Roles",
+			planning: "Planning",
+			execution: "Execution",
+			review: "Review",
+			recovery: "Recovery",
+			external: "External Issue",
+			diagnostics: "Diagnostics",
+			loading: "Loading…",
+			save: "Save",
+			stop: "Stop",
+			resume: "Resume safely"
+		};
+		//#endregion
+		//#region src/client/styles.ts
+		const STYLE = `
+.planx{padding:18px;max-width:1180px;color:inherit}
+.planx h2,.planx h3{margin:.2rem 0 .8rem}
+.planx-tabs{display:flex;gap:6px;flex-wrap:wrap;margin-bottom:16px}
+.planx-tabs button,.planx button{padding:7px 10px;border-radius:8px;border:1px solid color-mix(in srgb,currentColor 18%,transparent);background:transparent;color:inherit;cursor:pointer}
+.planx-tabs button[aria-selected="true"]{font-weight:700;outline:2px solid color-mix(in srgb,currentColor 35%,transparent)}
+.planx-card{border:1px solid color-mix(in srgb,currentColor 15%,transparent);border-radius:12px;padding:14px;margin:10px 0;min-width:0}
+.planx-grid{display:grid;grid-template-columns:repeat(auto-fit,minmax(250px,1fr));gap:10px}
+.planx-muted{opacity:.72}.planx-error{border-left:3px solid currentColor;padding:8px;margin:8px 0}
+.planx-chip{border-radius:999px!important;padding:4px 9px!important;white-space:nowrap}
+.planx-row{display:flex;gap:8px;align-items:center;flex-wrap:wrap}.planx-between{justify-content:space-between}
+.planx label{display:grid;gap:4px;margin:8px 0}.planx input,.planx select{background:transparent;color:inherit;border:1px solid color-mix(in srgb,currentColor 20%,transparent);border-radius:7px;padding:7px;min-width:0}
+.planx input[type="checkbox"]{width:auto}.planx pre{white-space:pre-wrap;word-break:break-word;max-height:320px;overflow:auto}
+.planx-overlay{position:fixed;inset:0;background:rgba(0,0,0,.38);display:flex;justify-content:flex-end;z-index:9999}
+.planx-dialog{width:min(720px,92vw);height:100%;overflow:auto;background:Canvas;color:CanvasText;padding:20px;box-shadow:0 0 30px rgba(0,0,0,.25)}
+.planx-kv{display:grid;grid-template-columns:minmax(120px,1fr) 2fr;gap:6px 12px}.planx-kv>span:nth-child(odd){opacity:.72}
+.planx progress{width:100%}
+@media (prefers-color-scheme: dark){.planx-dialog{background:#161616;color:#f2f2f2}}
+`;
+		//#endregion
+		//#region src/client/rpc-client.ts
+		/**
+		* Call the Host-owned exact `/api/plan-orchestrator/*` routes. DSH's web
+		* carrier authenticates these requests with the browser session cookie before
+		* dispatch, so this intentionally uses same-origin Fetch rather than the
+		* logical `ctx.connection.rpc` surface (which only exposes call/open in rc.1).
+		*/
+		function createRpc(fetcher = globalThis.fetch.bind(globalThis)) {
+			return async (method, body = {}, signal) => {
+				const response = await fetcher(`/api/plan-orchestrator/${encodeURIComponent(method)}`, {
+					method: "POST",
+					credentials: "same-origin",
+					headers: { "content-type": "application/json" },
+					body: JSON.stringify(body),
+					signal
+				});
+				let value;
+				try {
+					value = await response.json();
+				} catch {
+					throw new Error(`Plan Mode RPC returned invalid JSON (${response.status})`);
+				}
+				if (!response.ok || !value?.ok) throw new Error(value?.error?.message ?? `Plan Mode RPC failed (${response.status})`);
+				return value.data;
+			};
+		}
+		//#endregion
+		//#region src/client/components/Overview.tsx
+		function Overview({ diagnostics, settings }) {
+			const caps = [
+				["Native Plan Mode", diagnostics?.nativePlanMode],
+				["SDK parallel backend", diagnostics?.sdkAvailable],
+				["Git", diagnostics?.gitAvailable],
+				["LSP", diagnostics?.lspAvailable],
+				["gh", diagnostics?.ghAvailable],
+				["Settings writable", diagnostics?.settingsWritable]
+			];
+			return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+				className: "planx-grid",
+				children: [
+					/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+						className: "planx-card",
+						children: [
+							/* @__PURE__ */ (0, react_jsx_runtime.jsx)("h3", { children: "Compatibility" }),
+							/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", { children: ["DSH: ", diagnostics?.dshVersion ?? "detecting"] }),
+							/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", { children: ["Plugin: ", diagnostics?.pluginVersion ?? "1.0.0"] }),
+							/* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", { children: "Supported: 0.1.5-rc.1" }),
+							/* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", { children: "Preview: 0.1.5-rc.2" })
+						]
+					}),
+					/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+						className: "planx-card",
+						children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("h3", { children: "Capabilities" }), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+							className: "planx-kv",
+							children: caps.flatMap(([name, value]) => [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", { children: name }, `${name}-n`), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", { children: value === void 0 ? "—" : value ? "Available" : "Unavailable" }, `${name}-v`)])
+						})]
+					}),
+					/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+						className: "planx-card",
+						children: [
+							/* @__PURE__ */ (0, react_jsx_runtime.jsx)("h3", { children: "Safety" }),
+							/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", { children: ["Plan Orchestrator: ", settings?.enabled ? "enabled" : "disabled"] }),
+							/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", { children: ["Strict Planner read-only: ", settings?.planning?.strictReadOnly ? "on" : "off"] }),
+							/* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", { children: "Ownership / trusted validation: mandatory" }),
+							diagnostics?.readOnlyDegraded && /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+								role: "alert",
+								children: ["Degraded: ", diagnostics.readOnlyDegraded]
+							})
+						]
+					})
+				]
+			});
+		}
+		//#endregion
+		//#region src/client/components/Roles.tsx
+		const roleNames = [
+			"planner",
+			"worker",
+			"integrator",
+			"reviewer"
+		];
+		function Roles({ settings, catalog, onRole, rpc }) {
+			const [errors, setErrors] = (0, react.useState)({});
+			const validate = async (role, route) => {
+				if (route.mode !== "fixed" || !route.provider || !route.model) {
+					setErrors((e) => ({
+						...e,
+						[role]: ""
+					}));
+					return;
+				}
+				try {
+					await rpc("route-validate", { route });
+					setErrors((e) => ({
+						...e,
+						[role]: ""
+					}));
+				} catch (e) {
+					setErrors((x) => ({
+						...x,
+						[role]: e.message
+					}));
+				}
+			};
+			return /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+				className: "planx-grid",
+				children: roleNames.map((role) => {
+					const r = settings?.roles?.[role] ?? {
+						mode: "current",
+						fallbacks: []
+					};
+					const providers = (catalog ?? []).map((x) => x.provider);
+					const models = (catalog ?? []).find((x) => x.provider.id === r.provider)?.models ?? [];
+					const change = (next) => {
+						onRole(role, next);
+						validate(role, next);
+					};
+					return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+						className: "planx-card",
+						children: [
+							/* @__PURE__ */ (0, react_jsx_runtime.jsx)("h3", { children: role[0].toUpperCase() + role.slice(1) }),
+							/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("label", { children: ["Mode ", /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("select", {
+								value: r.mode,
+								onChange: (e) => change(e.target.value === "current" ? {
+									mode: "current",
+									fallbacks: r.fallbacks ?? []
+								} : {
+									...r,
+									mode: "fixed"
+								}),
+								children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("option", {
+									value: "current",
+									children: "Current Session"
+								}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("option", {
+									value: "fixed",
+									children: "Fixed"
+								})]
+							})] }),
+							r.mode === "fixed" && /* @__PURE__ */ (0, react_jsx_runtime.jsxs)(react_jsx_runtime.Fragment, { children: [
+								/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("label", { children: ["Provider ", /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("select", {
+									value: r.provider ?? "",
+									onChange: (e) => change({
+										...r,
+										provider: e.target.value,
+										model: ""
+									}),
+									children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("option", {
+										value: "",
+										children: "Select…"
+									}), providers.map((p) => /* @__PURE__ */ (0, react_jsx_runtime.jsx)("option", {
+										value: p.id,
+										children: p.name ?? p.id
+									}, p.id))]
+								})] }),
+								/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("label", { children: ["Model ", /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("select", {
+									value: r.model ?? "",
+									onChange: (e) => change({
+										...r,
+										model: e.target.value
+									}),
+									children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("option", {
+										value: "",
+										children: "Select…"
+									}), models.map((m) => /* @__PURE__ */ (0, react_jsx_runtime.jsx)("option", {
+										value: m.id,
+										children: m.name ?? m.id
+									}, m.id))]
+								})] }),
+								/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("label", { children: ["Reasoning effort ", /* @__PURE__ */ (0, react_jsx_runtime.jsx)("input", {
+									value: r.reasoningEffort ?? "",
+									onBlur: () => void validate(role, r),
+									onChange: (e) => onRole(role, {
+										...r,
+										reasoningEffort: e.target.value || void 0
+									})
+								})] }),
+								/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("label", { children: ["Max Tokens ", /* @__PURE__ */ (0, react_jsx_runtime.jsx)("input", {
+									type: "number",
+									min: 1,
+									value: r.maxTokens ?? "",
+									onBlur: () => void validate(role, r),
+									onChange: (e) => onRole(role, {
+										...r,
+										maxTokens: e.target.value ? Number(e.target.value) : void 0
+									})
+								})] })
+							] }),
+							errors[role] && /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+								className: "planx-error",
+								role: "alert",
+								children: errors[role]
+							}),
+							/* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
+								className: "planx-muted",
+								children: "Fallbacks remain host-validated at execution preflight."
+							})
+						]
+					}, role);
+				})
+			});
+		}
+		//#endregion
+		//#region src/client/components/Planning.tsx
+		function Planning({ settings, patch }) {
+			const p = settings.planning;
+			return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+				className: "planx-card",
+				children: [
+					/* @__PURE__ */ (0, react_jsx_runtime.jsx)("h3", { children: "Planning" }),
+					/* @__PURE__ */ (0, react_jsx_runtime.jsx)("label", { children: /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("span", { children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("input", {
+						type: "checkbox",
+						checked: p.adaptiveResearch,
+						onChange: (e) => patch({ adaptiveResearch: e.target.checked })
+					}), " Adaptive Research"] }) }),
+					/* @__PURE__ */ (0, react_jsx_runtime.jsx)("label", { children: /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("span", { children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("input", {
+						type: "checkbox",
+						checked: p.strictReadOnly,
+						onChange: (e) => patch({ strictReadOnly: e.target.checked })
+					}), " Strict Planner read-only"] }) }),
+					/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("label", { children: ["Initial read-file budget ", /* @__PURE__ */ (0, react_jsx_runtime.jsx)("input", {
+						type: "number",
+						min: 1,
+						max: 32,
+						value: p.maxInitialReadFiles,
+						onChange: (e) => patch({ maxInitialReadFiles: Number(e.target.value) })
+					})] }),
+					/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("label", { children: ["Soft input-token budget ", /* @__PURE__ */ (0, react_jsx_runtime.jsx)("input", {
+						type: "number",
+						min: 1e3,
+						value: p.softInputTokens,
+						onChange: (e) => patch({ softInputTokens: Number(e.target.value) })
+					})] }),
+					/* @__PURE__ */ (0, react_jsx_runtime.jsx)("label", { children: /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("span", { children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("input", {
+						type: "checkbox",
+						checked: p.progressiveDiscovery,
+						onChange: (e) => patch({ progressiveDiscovery: e.target.checked })
+					}), " Progressive discovery"] }) }),
+					/* @__PURE__ */ (0, react_jsx_runtime.jsx)("label", { children: /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("span", { children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("input", {
+						type: "checkbox",
+						checked: p.requireExpansionReason,
+						onChange: (e) => patch({ requireExpansionReason: e.target.checked })
+					}), " Require reason before context expansion"] }) })
+				]
+			});
+		}
+		//#endregion
+		//#region src/client/components/Execution.tsx
+		function Execution({ settings, patch }) {
+			const e = settings.execution;
+			return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+				className: "planx-card",
+				children: [
+					/* @__PURE__ */ (0, react_jsx_runtime.jsx)("h3", { children: "Execution" }),
+					/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("label", { children: ["Parallel mode ", /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("select", {
+						value: e.parallelMode,
+						onChange: (x) => patch({ parallelMode: x.target.value }),
+						children: [
+							/* @__PURE__ */ (0, react_jsx_runtime.jsx)("option", {
+								value: "auto",
+								children: "Auto"
+							}),
+							/* @__PURE__ */ (0, react_jsx_runtime.jsx)("option", {
+								value: "serial",
+								children: "Serial"
+							}),
+							/* @__PURE__ */ (0, react_jsx_runtime.jsx)("option", {
+								value: "worktree",
+								children: "Worktree when safe"
+							})
+						]
+					})] }),
+					/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("label", { children: ["Max parallel Workers ", /* @__PURE__ */ (0, react_jsx_runtime.jsx)("input", {
+						type: "number",
+						min: 1,
+						max: 8,
+						value: e.maxParallelWorkers,
+						onChange: (x) => patch({ maxParallelWorkers: Number(x.target.value) })
+					})] }),
+					/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("label", { children: ["SDK child profile ", /* @__PURE__ */ (0, react_jsx_runtime.jsx)("input", {
+						value: e.sdkProfile,
+						onChange: (x) => patch({ sdkProfile: x.target.value })
+					})] }),
+					/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("label", { children: ["Mutation role timeout (ms) ", /* @__PURE__ */ (0, react_jsx_runtime.jsx)("input", {
+						type: "number",
+						min: 1e3,
+						max: 36e5,
+						value: e.roleTimeoutMs,
+						onChange: (x) => patch({ roleTimeoutMs: Number(x.target.value) })
+					})] }),
+					/* @__PURE__ */ (0, react_jsx_runtime.jsx)("label", { children: /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("span", { children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("input", {
+						type: "checkbox",
+						checked: e.keepFailedWorktrees,
+						onChange: (x) => patch({ keepFailedWorktrees: x.target.checked })
+					}), " Retain failed worktrees for evidence"] }) }),
+					/* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
+						className: "planx-muted",
+						children: "The timeout is enforced for native/SDK Worker, Integrator and targeted-fix mutation roles. Explicit ownership is always enforced and cannot be disabled."
+					})
+				]
+			});
+		}
+		//#endregion
+		//#region src/client/components/Review.tsx
+		function Review({ settings, patch }) {
+			const r = settings.review;
+			return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+				className: "planx-card",
+				children: [
+					/* @__PURE__ */ (0, react_jsx_runtime.jsx)("h3", { children: "Review" }),
+					/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("label", { children: ["Maximum targeted-fix rounds ", /* @__PURE__ */ (0, react_jsx_runtime.jsx)("input", {
+						type: "number",
+						min: 0,
+						max: 5,
+						value: r.maxReviewRounds,
+						onChange: (e) => patch({ maxReviewRounds: Number(e.target.value) })
+					})] }),
+					/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("label", { children: ["Reviewer protocol retry ", /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("select", {
+						value: r.protocolRetry,
+						onChange: (e) => patch({ protocolRetry: Number(e.target.value) }),
+						children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("option", {
+							value: 0,
+							children: "0"
+						}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("option", {
+							value: 1,
+							children: "1"
+						})]
+					})] }),
+					/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("label", { children: ["Per-stream output cap (bytes) ", /* @__PURE__ */ (0, react_jsx_runtime.jsx)("input", {
+						type: "number",
+						min: 1024,
+						max: 16777216,
+						value: r.outputCapBytes,
+						onChange: (e) => patch({ outputCapBytes: Number(e.target.value) })
+					})] }),
+					/* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
+						className: "planx-muted",
+						children: "Trusted host validation is mandatory. Worker self-reports are never accepted as proof."
+					})
+				]
+			});
+		}
+		//#endregion
+		//#region src/client/components/Recovery.tsx
+		function Recovery({ rpc, allowSafeResume }) {
+			const [runs, setRuns] = (0, react.useState)([]), [error, setError] = (0, react.useState)("");
+			const load = () => rpc("run-list", {}).then((r) => {
+				setRuns(r);
+				setError("");
+			}).catch((e) => setError(e.message));
+			(0, react.useEffect)(() => {
+				load();
+			}, []);
+			return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+				className: "planx-card",
+				children: [
+					/* @__PURE__ */ (0, react_jsx_runtime.jsx)("h3", { children: "Recovery" }),
+					error && /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+						role: "alert",
+						children: error
+					}),
+					/* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
+						className: "planx-muted",
+						children: "Resume is available only when Safe Resume is enabled and an INTERRUPTED run's checkpoint still matches HEAD, ownership and working-tree fingerprint. No reset/clean/stash recovery exists."
+					}),
+					runs.length === 0 ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", { children: "No loaded runs." }) : runs.slice(0, 20).map((run) => /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+						className: "planx-row",
+						children: [
+							/* @__PURE__ */ (0, react_jsx_runtime.jsx)("code", { children: run.runId.slice(0, 8) }),
+							/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", { children: run.phase }),
+							run.phase === "INTERRUPTED" && /* @__PURE__ */ (0, react_jsx_runtime.jsx)("button", {
+								disabled: !allowSafeResume,
+								title: !allowSafeResume ? "Safe Resume is disabled in Plan Mode settings." : void 0,
+								onClick: async () => {
+									const v = await rpc("run-resume", { runId: run.runId });
+									if (!v.ok) setError(v.reason);
+									await load();
+								},
+								children: "Resume safely"
+							}),
+							[
+								"COMPLETE",
+								"FAILED",
+								"BLOCKED",
+								"CANCELLED"
+							].includes(run.phase) && /* @__PURE__ */ (0, react_jsx_runtime.jsx)("button", {
+								onClick: async () => {
+									if (confirm("Cleanup this terminal run?")) {
+										await rpc("run-cleanup", { runId: run.runId });
+										await load();
+									}
+								},
+								children: "Cleanup"
+							})
+						]
+					}, run.runId))
+				]
+			});
+		}
+		//#endregion
+		//#region src/client/components/ExternalIssue.tsx
+		function ExternalIssue({ settings, patch }) {
+			const x = settings.externalIssue;
+			return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+				className: "planx-card",
+				children: [
+					/* @__PURE__ */ (0, react_jsx_runtime.jsx)("h3", { children: "External Issue" }),
+					/* @__PURE__ */ (0, react_jsx_runtime.jsx)("label", { children: /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("span", { children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("input", {
+						type: "checkbox",
+						checked: x.enabled,
+						onChange: (e) => patch({ enabled: e.target.checked })
+					}), " Enable /plan-issue"] }) }),
+					/* @__PURE__ */ (0, react_jsx_runtime.jsx)("label", { children: /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("span", { children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("input", {
+						type: "checkbox",
+						checked: x.publishAfterPass,
+						disabled: !x.enabled,
+						onChange: (e) => patch({ publishAfterPass: e.target.checked })
+					}), " After Reviewer PASS, commit/push/create or reuse PR"] }) }),
+					/* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
+						className: "planx-muted",
+						children: "Publication remains fail-closed: trusted revision, repo match, current validation receipts and Reviewer PASS are required. Force push and auto-merge are never used."
+					})
+				]
+			});
+		}
+		//#endregion
+		//#region src/client/components/Diagnostics.tsx
+		function Diagnostics({ diagnostics }) {
+			return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+				className: "planx-card",
+				children: [
+					/* @__PURE__ */ (0, react_jsx_runtime.jsx)("h3", { children: "Diagnostics" }),
+					/* @__PURE__ */ (0, react_jsx_runtime.jsx)("pre", { children: JSON.stringify(diagnostics ?? {}, null, 2) }),
+					/* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
+						className: "planx-muted",
+						children: "Diagnostics intentionally expose capability state and plugin storage location, never credentials or raw validation logs."
+					})
+				]
+			});
+		}
+		//#endregion
+		//#region src/contract/settings.ts
+		const SETTINGS_NAMESPACE = "plan-orchestrator";
+		const ROLE_NAMES = [
+			"planner",
+			"worker",
+			"integrator",
+			"reviewer"
+		];
+		const SETTINGS_KEYS = /* @__PURE__ */ new Set([
+			"enabled",
+			"roles",
+			"planning",
+			"execution",
+			"review",
+			"recovery",
+			"externalIssue",
+			"workspaceOverrides"
+		]);
+		const ROUTE_KEYS = /* @__PURE__ */ new Set([
+			"mode",
+			"provider",
+			"model",
+			"reasoningEffort",
+			"maxTokens",
+			"fallbacks"
+		]);
+		const CHOICE_KEYS = /* @__PURE__ */ new Set([
+			"provider",
+			"model",
+			"reasoningEffort",
+			"maxTokens"
+		]);
+		const PLANNING_KEYS = /* @__PURE__ */ new Set([
+			"adaptiveResearch",
+			"strictReadOnly",
+			"maxInitialReadFiles",
+			"softInputTokens",
+			"progressiveDiscovery",
+			"requireExpansionReason"
+		]);
+		const EXECUTION_KEYS = /* @__PURE__ */ new Set([
+			"maxParallelWorkers",
+			"parallelMode",
+			"requireExplicitOwnership",
+			"keepFailedWorktrees",
+			"sdkProfile",
+			"roleTimeoutMs"
+		]);
+		const REVIEW_KEYS = /* @__PURE__ */ new Set([
+			"maxReviewRounds",
+			"protocolRetry",
+			"trustedValidation",
+			"outputCapBytes"
+		]);
+		const RECOVERY_KEYS = /* @__PURE__ */ new Set(["allowSafeResume"]);
+		const EXTERNAL_KEYS = /* @__PURE__ */ new Set(["enabled", "publishAfterPass"]);
+		const WORKSPACE_KEYS = /* @__PURE__ */ new Set(["roles"]);
+		const defaultRoute = () => ({
+			mode: "current",
+			fallbacks: []
+		});
+		Object.freeze({
+			enabled: true,
+			roles: {
+				planner: defaultRoute(),
+				worker: defaultRoute(),
+				integrator: defaultRoute(),
+				reviewer: defaultRoute()
+			},
+			planning: {
+				adaptiveResearch: true,
+				strictReadOnly: true,
+				maxInitialReadFiles: 6,
+				softInputTokens: 2e4,
+				progressiveDiscovery: true,
+				requireExpansionReason: true
+			},
+			execution: {
+				maxParallelWorkers: 3,
+				parallelMode: "auto",
+				requireExplicitOwnership: true,
+				keepFailedWorktrees: true,
+				sdkProfile: "sdk",
+				roleTimeoutMs: 9e5
+			},
+			review: {
+				maxReviewRounds: 2,
+				protocolRetry: 1,
+				trustedValidation: true,
+				outputCapBytes: 16 * 1024 * 1024
+			},
+			recovery: { allowSafeResume: true },
+			externalIssue: {
+				enabled: false,
+				publishAfterPass: false
+			},
+			workspaceOverrides: {}
+		});
+		function object(value, where) {
+			if (typeof value !== "object" || value === null || Array.isArray(value)) throw new Error(`${where} must be an object`);
+			return value;
+		}
+		function strictKeys(value, allowed, where) {
+			const unknown = Object.keys(value).filter((key) => !allowed.has(key));
+			if (unknown.length > 0) throw new Error(`${where} has unknown field(s): ${unknown.join(", ")}`);
+		}
+		function bool(value, where) {
+			if (typeof value !== "boolean") throw new Error(`${where} must be boolean`);
+			return value;
+		}
+		function integer(value, where, min, max) {
+			if (!Number.isSafeInteger(value) || value < min || value > max) throw new Error(`${where} must be an integer from ${min} through ${max}`);
+			return value;
+		}
+		function optionalString(value, where, max = 256) {
+			if (value === void 0) return void 0;
+			if (typeof value !== "string" || value.length === 0 || value.length > max || value.includes("\0")) throw new Error(`${where} invalid`);
+			return value;
+		}
+		function routeChoice(value, where) {
+			const x = object(value, where);
+			strictKeys(x, CHOICE_KEYS, where);
+			const provider = optionalString(x.provider, `${where}.provider`);
+			const model = optionalString(x.model, `${where}.model`);
+			if (!provider || !model) throw new Error(`${where} needs provider and model`);
+			const reasoningEffort = optionalString(x.reasoningEffort, `${where}.reasoningEffort`, 64);
+			const maxTokens = x.maxTokens === void 0 ? void 0 : integer(x.maxTokens, `${where}.maxTokens`, 1, 2e6);
+			return {
+				provider,
+				model,
+				...reasoningEffort ? { reasoningEffort } : {},
+				...maxTokens ? { maxTokens } : {}
+			};
+		}
+		function roleRoute(value, where, workspace) {
+			const x = object(value, where);
+			strictKeys(x, ROUTE_KEYS, where);
+			const allowedModes = workspace ? [
+				"inherit",
+				"current",
+				"fixed"
+			] : ["current", "fixed"];
+			if (typeof x.mode !== "string" || !allowedModes.includes(x.mode)) throw new Error(`${where}.mode invalid`);
+			const mode = x.mode;
+			const provider = optionalString(x.provider, `${where}.provider`);
+			const model = optionalString(x.model, `${where}.model`);
+			const reasoningEffort = optionalString(x.reasoningEffort, `${where}.reasoningEffort`, 64);
+			const maxTokens = x.maxTokens === void 0 ? void 0 : integer(x.maxTokens, `${where}.maxTokens`, 1, 2e6);
+			if (mode === "fixed" && (!provider || !model)) throw new Error(`${where} fixed route needs provider and model`);
+			if (mode !== "fixed" && (provider !== void 0 || model !== void 0 || reasoningEffort !== void 0 || maxTokens !== void 0)) throw new Error(`${where} ${mode} route cannot carry fixed-route fields`);
+			if (!Array.isArray(x.fallbacks) || x.fallbacks.length > 8) throw new Error(`${where}.fallbacks invalid`);
+			return {
+				mode,
+				fallbacks: x.fallbacks.map((item, index) => routeChoice(item, `${where}.fallbacks[${index}]`)),
+				...provider ? { provider } : {},
+				...model ? { model } : {},
+				...reasoningEffort ? { reasoningEffort } : {},
+				...maxTokens ? { maxTokens } : {}
+			};
+		}
+		function section(value, allowed, where) {
+			const x = object(value, where);
+			strictKeys(x, allowed, where);
+			return x;
+		}
+		function validateSettings(value) {
+			const x = object(value, "settings");
+			strictKeys(x, SETTINGS_KEYS, "settings");
+			const rolesRaw = object(x.roles, "settings.roles");
+			strictKeys(rolesRaw, new Set(ROLE_NAMES), "settings.roles");
+			const roles = Object.fromEntries(ROLE_NAMES.map((role) => [role, roleRoute(rolesRaw[role], `settings.roles.${role}`, false)]));
+			const planning = section(x.planning, PLANNING_KEYS, "settings.planning");
+			const execution = section(x.execution, EXECUTION_KEYS, "settings.execution");
+			const review = section(x.review, REVIEW_KEYS, "settings.review");
+			const recovery = section(x.recovery, RECOVERY_KEYS, "settings.recovery");
+			const externalIssue = section(x.externalIssue, EXTERNAL_KEYS, "settings.externalIssue");
+			const workspaceRaw = object(x.workspaceOverrides, "settings.workspaceOverrides");
+			const workspaceOverrides = {};
+			if (Object.keys(workspaceRaw).length > 256) throw new Error("settings.workspaceOverrides has too many entries");
+			for (const [workspaceKey, raw] of Object.entries(workspaceRaw)) {
+				if (!/^[A-Za-z0-9_-]{16,128}$/.test(workspaceKey)) throw new Error(`invalid workspace override key: ${workspaceKey}`);
+				const override = object(raw, `settings.workspaceOverrides.${workspaceKey}`);
+				strictKeys(override, WORKSPACE_KEYS, `settings.workspaceOverrides.${workspaceKey}`);
+				const result = {};
+				if (override.roles !== void 0) {
+					const roleObject = object(override.roles, `settings.workspaceOverrides.${workspaceKey}.roles`);
+					strictKeys(roleObject, new Set(ROLE_NAMES), `settings.workspaceOverrides.${workspaceKey}.roles`);
+					result.roles = {};
+					for (const [role, route] of Object.entries(roleObject)) result.roles[role] = roleRoute(route, `settings.workspaceOverrides.${workspaceKey}.roles.${role}`, true);
+				}
+				workspaceOverrides[workspaceKey] = result;
+			}
+			if (bool(execution.requireExplicitOwnership, "settings.execution.requireExplicitOwnership") !== true) throw new Error("settings.execution.requireExplicitOwnership is a security invariant and must be true");
+			if (bool(review.trustedValidation, "settings.review.trustedValidation") !== true) throw new Error("settings.review.trustedValidation is a security invariant and must be true");
+			const parallelMode = execution.parallelMode;
+			if (![
+				"auto",
+				"serial",
+				"worktree"
+			].includes(String(parallelMode))) throw new Error("settings.execution.parallelMode invalid");
+			return {
+				enabled: bool(x.enabled, "settings.enabled"),
+				roles,
+				planning: {
+					adaptiveResearch: bool(planning.adaptiveResearch, "settings.planning.adaptiveResearch"),
+					strictReadOnly: bool(planning.strictReadOnly, "settings.planning.strictReadOnly"),
+					maxInitialReadFiles: integer(planning.maxInitialReadFiles, "settings.planning.maxInitialReadFiles", 1, 32),
+					softInputTokens: integer(planning.softInputTokens, "settings.planning.softInputTokens", 1e3, 2e6),
+					progressiveDiscovery: bool(planning.progressiveDiscovery, "settings.planning.progressiveDiscovery"),
+					requireExpansionReason: bool(planning.requireExpansionReason, "settings.planning.requireExpansionReason")
+				},
+				execution: {
+					maxParallelWorkers: integer(execution.maxParallelWorkers, "settings.execution.maxParallelWorkers", 1, 8),
+					parallelMode,
+					requireExplicitOwnership: true,
+					keepFailedWorktrees: bool(execution.keepFailedWorktrees, "settings.execution.keepFailedWorktrees"),
+					sdkProfile: optionalString(execution.sdkProfile, "settings.execution.sdkProfile", 128),
+					roleTimeoutMs: integer(execution.roleTimeoutMs, "settings.execution.roleTimeoutMs", 1e3, 36e5)
+				},
+				review: {
+					maxReviewRounds: integer(review.maxReviewRounds, "settings.review.maxReviewRounds", 0, 5),
+					protocolRetry: integer(review.protocolRetry, "settings.review.protocolRetry", 0, 1),
+					trustedValidation: true,
+					outputCapBytes: integer(review.outputCapBytes, "settings.review.outputCapBytes", 1024, 16 * 1024 * 1024)
+				},
+				recovery: { allowSafeResume: bool(recovery.allowSafeResume, "settings.recovery.allowSafeResume") },
+				externalIssue: {
+					enabled: bool(externalIssue.enabled, "settings.externalIssue.enabled"),
+					publishAfterPass: bool(externalIssue.publishAfterPass, "settings.externalIssue.publishAfterPass")
+				},
+				workspaceOverrides
+			};
+		}
+		//#endregion
+		//#region src/client/section.tsx
+		const tabs = [
+			["overview", "Overview"],
+			["roles", "Roles"],
+			["planning", "Planning"],
+			["execution", "Execution"],
+			["review", "Review"],
+			["recovery", "Recovery"],
+			["external", "ExternalIssue"],
+			["diagnostics", "Diagnostics"]
+		];
+		const settingFields = [
+			"enabled",
+			"roles",
+			"planning",
+			"execution",
+			"review",
+			"recovery",
+			"externalIssue",
+			"workspaceOverrides"
+		];
+		function PlanModeSection({ rpc, t, settingsScope }) {
+			const [tab, setTab] = (0, react.useState)("overview"), [diag, setDiag] = (0, react.useState)(), [settings, setSettings] = (0, react.useState)(), [catalog, setCatalog] = (0, react.useState)([]), [dirty, setDirty] = (0, react.useState)(false), [error, setError] = (0, react.useState)("");
+			const draftRevision = (0, react.useRef)();
+			(0, react.useEffect)(() => settingsScope.subscribe(() => {
+				const snap = settingsScope.getSnapshot();
+				if (!dirty && snap.status === "ready" && snap.value) {
+					setSettings(snap.value);
+					draftRevision.current = snap.revision;
+				}
+			}), [settingsScope, dirty]);
+			(0, react.useEffect)(() => {
+				const snap = settingsScope.getSnapshot();
+				if (snap.status === "ready" && snap.value) {
+					setSettings(snap.value);
+					draftRevision.current = snap.revision;
+				}
+				Promise.all([rpc("diagnostics"), rpc("model-catalog")]).then(([d, c]) => {
+					setDiag(d);
+					setCatalog(c);
+				}).catch((e) => setError(e.message));
+			}, [rpc, settingsScope]);
+			const mutate = (path, patch) => {
+				setSettings((s) => ({
+					...s,
+					[path]: {
+						...s[path],
+						...patch
+					}
+				}));
+				setDirty(true);
+			};
+			const onRole = (role, value) => {
+				setSettings((s) => ({
+					...s,
+					roles: {
+						...s.roles,
+						[role]: value
+					}
+				}));
+				setDirty(true);
+			};
+			const save = async () => {
+				try {
+					const checked = validateSettings(settings);
+					const ops = settingFields.map((field) => ({
+						op: "set",
+						path: [field],
+						value: checked[field]
+					}));
+					const expected = draftRevision.current;
+					await settingsScope.mutate(ops, expected);
+					const snap = settingsScope.getSnapshot();
+					if (snap.status !== "ready" || JSON.stringify(snap.value) !== JSON.stringify(checked)) throw new Error("Settings changed concurrently; your draft was not silently overwritten. Reload the current values and reapply the change.");
+					setSettings(snap.value);
+					draftRevision.current = snap.revision;
+					setDirty(false);
+					setError("");
+				} catch (e) {
+					setError(e.message);
+				}
+			};
+			const tabRefs = (0, react.useRef)([]);
+			const key = (event, index) => {
+				if (![
+					"ArrowLeft",
+					"ArrowRight",
+					"Home",
+					"End"
+				].includes(event.key)) return;
+				event.preventDefault();
+				let next = index;
+				if (event.key === "ArrowLeft") next = (index + tabs.length - 1) % tabs.length;
+				if (event.key === "ArrowRight") next = (index + 1) % tabs.length;
+				if (event.key === "Home") next = 0;
+				if (event.key === "End") next = tabs.length - 1;
+				setTab(tabs[next][0]);
+				tabRefs.current[next]?.focus();
+			};
+			if (!settings) return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("section", {
+				className: "planx",
+				children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", { children: t?.("loading") ?? "Loading…" }), error && /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+					role: "alert",
+					children: error
+				})]
+			});
+			let content;
+			if (tab === "overview") content = /* @__PURE__ */ (0, react_jsx_runtime.jsx)(Overview, {
+				diagnostics: diag,
+				settings
+			});
+			else if (tab === "roles") content = /* @__PURE__ */ (0, react_jsx_runtime.jsx)(Roles, {
+				settings,
+				catalog,
+				onRole,
+				rpc
+			});
+			else if (tab === "planning") content = /* @__PURE__ */ (0, react_jsx_runtime.jsx)(Planning, {
+				settings,
+				patch: (p) => mutate("planning", p)
+			});
+			else if (tab === "execution") content = /* @__PURE__ */ (0, react_jsx_runtime.jsx)(Execution, {
+				settings,
+				patch: (p) => mutate("execution", p)
+			});
+			else if (tab === "review") content = /* @__PURE__ */ (0, react_jsx_runtime.jsx)(Review, {
+				settings,
+				patch: (p) => mutate("review", p)
+			});
+			else if (tab === "recovery") content = /* @__PURE__ */ (0, react_jsx_runtime.jsx)(Recovery, {
+				rpc,
+				allowSafeResume: settings.recovery.allowSafeResume
+			});
+			else if (tab === "external") content = /* @__PURE__ */ (0, react_jsx_runtime.jsx)(ExternalIssue, {
+				settings,
+				patch: (p) => mutate("externalIssue", p)
+			});
+			else content = /* @__PURE__ */ (0, react_jsx_runtime.jsx)(Diagnostics, { diagnostics: diag });
+			return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("section", {
+				className: "planx",
+				children: [
+					/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+						className: "planx-row planx-between",
+						children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("h2", { children: "Plan Mode" }), /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+							className: "planx-row",
+							children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("label", { children: /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("span", { children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("input", {
+								type: "checkbox",
+								checked: settings.enabled,
+								onChange: (e) => {
+									setSettings((s) => ({
+										...s,
+										enabled: e.target.checked
+									}));
+									setDirty(true);
+								}
+							}), " Enabled"] }) }), dirty && /* @__PURE__ */ (0, react_jsx_runtime.jsx)("button", {
+								onClick: save,
+								children: t?.("save") ?? "Save"
+							})]
+						})]
+					}),
+					error && /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+						role: "alert",
+						className: "planx-error",
+						children: error
+					}),
+					/* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+						className: "planx-tabs",
+						role: "tablist",
+						"aria-label": "Plan Mode settings",
+						children: tabs.map(([id, label], index) => /* @__PURE__ */ (0, react_jsx_runtime.jsx)("button", {
+							ref: (el) => {
+								tabRefs.current[index] = el;
+							},
+							role: "tab",
+							"aria-selected": tab === id,
+							tabIndex: tab === id ? 0 : -1,
+							onKeyDown: (e) => key(e, index),
+							onClick: () => setTab(id),
+							children: t?.(id) ?? label
+						}, id))
+					}),
+					content
+				]
+			});
+		}
+		//#endregion
+		//#region src/client/run-chip.tsx
+		function RunChip({ rpc, sessionId, overlay }) {
+			const [run, setRun] = (0, react.useState)();
+			(0, react.useEffect)(() => {
+				let live = true;
+				const load = () => rpc("run-list", { sessionId }).then((rows) => {
+					if (live) setRun(rows[0]);
+				}).catch(() => {});
+				load();
+				const timer = setInterval(load, 2500);
+				return () => {
+					live = false;
+					clearInterval(timer);
+				};
+			}, [rpc, sessionId]);
+			if (!run) return null;
+			return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("button", {
+				className: "planx-chip",
+				"aria-label": `Plan Run ${run.phase}`,
+				onClick: () => overlay.open(run.runId),
+				children: [
+					"Plan Run · ",
+					run.tasksDone ?? 0,
+					"/",
+					run.tasksTotal ?? 0,
+					" · ",
+					run.phase
+				]
+			});
+		}
+		//#endregion
+		//#region src/client/run-overlay.tsx
+		var RunOverlayService = class {
+			#runId;
+			#listeners = /* @__PURE__ */ new Set();
+			#returnFocus = null;
+			get runId() {
+				return this.#runId;
+			}
+			open(runId) {
+				if (typeof document !== "undefined" && document.activeElement instanceof HTMLElement) this.#returnFocus = document.activeElement;
+				this.#runId = runId;
+				this.#emit();
+			}
+			close() {
+				if (this.#runId === void 0) return;
+				this.#runId = void 0;
+				this.#emit();
+				const target = this.#returnFocus;
+				this.#returnFocus = null;
+				if (target?.isConnected) queueMicrotask(() => target.focus());
+			}
+			subscribe(listener) {
+				this.#listeners.add(listener);
+				return () => this.#listeners.delete(listener);
+			}
+			#emit() {
+				for (const listener of this.#listeners) listener();
+			}
+		};
+		function RunOverlay({ service, rpc, t }) {
+			const [runId, setRunId] = (0, react.useState)(service.runId);
+			const [run, setRun] = (0, react.useState)();
+			const [error, setError] = (0, react.useState)("");
+			const dialogRef = (0, react.useRef)(null);
+			const titleId = "planx-run-dialog-title";
+			(0, react.useEffect)(() => service.subscribe(() => setRunId(service.runId)), [service]);
+			(0, react.useEffect)(() => {
+				if (!runId) {
+					setRun(void 0);
+					return;
+				}
+				let live = true;
+				const load = async () => {
+					try {
+						const value = await rpc("run-detail", { runId });
+						if (live) {
+							setRun(value);
+							setError("");
+						}
+					} catch (e) {
+						if (live) setError(e.message);
+					}
+				};
+				load();
+				const timer = setInterval(load, 2500);
+				return () => {
+					live = false;
+					clearInterval(timer);
+				};
+			}, [runId, rpc]);
+			(0, react.useEffect)(() => {
+				if (!runId) return;
+				dialogRef.current?.focus();
+				const onKeyDown = (event) => {
+					if (event.key === "Escape") {
+						event.preventDefault();
+						service.close();
+					}
+				};
+				document.addEventListener("keydown", onKeyDown);
+				return () => document.removeEventListener("keydown", onKeyDown);
+			}, [runId, service]);
+			if (!runId) return null;
+			return /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+				className: "planx-overlay",
+				role: "presentation",
+				onMouseDown: (event) => {
+					if (event.target === event.currentTarget) service.close();
+				},
+				children: /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("section", {
+					ref: dialogRef,
+					role: "dialog",
+					"aria-modal": "true",
+					"aria-labelledby": titleId,
+					className: "planx-dialog",
+					tabIndex: -1,
+					children: [
+						/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+							className: "planx-row planx-between",
+							children: [/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("b", {
+								id: titleId,
+								children: ["Plan Run ", runId]
+							}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("button", {
+								"aria-label": "Close",
+								onClick: () => service.close(),
+								children: "×"
+							})]
+						}),
+						error && /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+							role: "alert",
+							className: "planx-error",
+							children: error
+						}),
+						!run ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", { children: t?.("loading") ?? "Loading…" }) : /* @__PURE__ */ (0, react_jsx_runtime.jsxs)(react_jsx_runtime.Fragment, { children: [
+							/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("p", { children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("b", { children: run.phase }), run.message ? ` · ${run.message}` : ""] }),
+							/* @__PURE__ */ (0, react_jsx_runtime.jsx)("progress", {
+								"aria-label": "Plan task progress",
+								max: Math.max(1, run.tasksTotal ?? 1),
+								value: run.tasksDone ?? 0
+							}),
+							/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("p", { children: [
+								run.tasksDone ?? 0,
+								"/",
+								run.tasksTotal ?? 0,
+								" tasks · review round ",
+								run.reviewRound ?? 0
+							] }),
+							run.activeTaskIds?.length > 0 && /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("p", { children: ["Active: ", run.activeTaskIds.join(", ")] }),
+							run.review && /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+								className: "planx-card",
+								children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("b", { children: "Review" }), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("pre", { children: JSON.stringify(run.review, null, 2) })]
+							}),
+							Array.isArray(run.receipts) && /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+								className: "planx-card",
+								children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("b", { children: "Validation receipts" }), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("pre", { children: JSON.stringify(run.receipts, null, 2) })]
+							}),
+							run.usage && /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+								className: "planx-card",
+								children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("b", { children: "Usage" }), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("pre", { children: JSON.stringify(run.usage, null, 2) })]
+							}),
+							Array.isArray(run.worktrees) && run.worktrees.length > 0 && /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+								className: "planx-card",
+								children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("b", { children: "Worktrees" }), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("pre", { children: JSON.stringify(run.worktrees.map((w) => ({
+									taskId: w.taskId,
+									status: w.status,
+									baseHead: w.baseHead
+								})), null, 2) })]
+							}),
+							/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+								className: "planx-row",
+								children: [
+									![
+										"COMPLETE",
+										"FAILED",
+										"BLOCKED",
+										"CANCELLED"
+									].includes(run.phase) && /* @__PURE__ */ (0, react_jsx_runtime.jsx)("button", {
+										onClick: () => rpc("run-cancel", { runId }).then(() => setRun((r) => ({
+											...r,
+											phase: "CANCELLED"
+										}))).catch((e) => setError(e.message)),
+										children: t?.("stop") ?? "Stop"
+									}),
+									run.phase === "INTERRUPTED" && /* @__PURE__ */ (0, react_jsx_runtime.jsx)("button", {
+										onClick: async () => {
+											try {
+												const result = await rpc("run-resume", { runId });
+												if (!result?.ok) setError(result?.reason ?? "Resume blocked");
+											} catch (e) {
+												setError(e.message);
+											}
+										},
+										children: t?.("resume") ?? "Resume safely"
+									}),
+									[
+										"COMPLETE",
+										"FAILED",
+										"BLOCKED",
+										"CANCELLED"
+									].includes(run.phase) && /* @__PURE__ */ (0, react_jsx_runtime.jsx)("button", {
+										onClick: async () => {
+											if (confirm("Remove Plan Orchestrator run artifacts and owned worktrees?")) try {
+												await rpc("run-cleanup", { runId });
+												service.close();
+											} catch (e) {
+												setError(e.message);
+											}
+										},
+										children: "Cleanup"
+									})
+								]
+							})
+						] })
+					]
+				})
+			});
+		}
+		//#endregion
+		//#region src/client/index.tsx
+		const inject = [
+			"slots",
+			"locale",
+			"connection",
+			"settingsScope",
+			"sessions"
+		];
+		function apply(ctx) {
+			const NS = "plan-orchestrator";
+			ctx.effect(() => ctx.locale.register(NS, {
+				zh,
+				en
+			}), "plan-orchestrator: locale");
+			ctx.effect(() => {
+				const style = document.createElement("style");
+				style.dataset.plugin = "dsh-plan-orchestrator";
+				style.textContent = STYLE;
+				document.head.append(style);
+				return () => style.remove();
+			}, "plan-orchestrator: style");
+			const t = ctx.locale.bind(NS);
+			const rpc = createRpc();
+			const settingsScope = ctx.settingsScope.bind({
+				namespace: SETTINGS_NAMESPACE,
+				decode(value) {
+					try {
+						return validateSettings(value);
+					} catch {
+						return;
+					}
+				}
+			});
+			const overlay = new RunOverlayService();
+			ctx.effect(() => () => overlay.close(), "plan-orchestrator: overlay service");
+			ctx.slots.inject("settings.section", () => ctx.slots.register({
+				name: "settings.section",
+				id: "plan-orchestrator",
+				order: 20,
+				label: () => t("nav"),
+				locale: NS,
+				inject: () => ({
+					rpc,
+					t,
+					settingsScope
+				})
+			}, PlanModeSection));
+			ctx.slots.inject("conversation.input.right", () => ctx.slots.register({
+				name: "conversation.input.right",
+				id: "plan-orchestrator-run",
+				order: 20,
+				locale: NS,
+				inject: (sessionId) => ({
+					rpc,
+					sessionId,
+					overlay
+				})
+			}, RunChip));
+			ctx.slots.inject("shell.overlay", () => ctx.slots.register({
+				name: "shell.overlay",
+				id: "plan-orchestrator-run-overlay",
+				order: 21,
+				locale: NS,
+				inject: () => ({
+					service: overlay,
+					rpc,
+					t
+				})
+			}, RunOverlay));
+		}
+		//#endregion
+		exports.apply = apply;
+		exports.inject = inject;
+		return module.exports;
+	}
+});
+
+//# sourceMappingURL=client.js.map