@gilbertgt/dsh-plan-orchestrator 1.0.0

package/lib/index.js

@@ -0,0 +1,3776 @@
+import { A as validatePlanArtifact, C as git, D as normalizeOwnedPath, E as extractPlanArtifact, O as parseValidationCommand, S as fullHead, _ as readJson, b as changedPaths, c as trustedIssueTexts, d as hashBytes, f as assertOwnedPaths, g as confined, h as atomicJson, i as ghRepository, k as schedulerPathIdentity, l as assertTrustedReceipts, m as RunStore, n as ghPreflight, o as prepareIssueBranch, p as disjointOwnership, s as remotePr, t as fetchIssue, u as receiptIndex, v as stateRoot, w as repoRoot, x as decodeUtf8Strict, y as assertRepoPathsConfined } from "./github-Cy4Pm35G.js";
+import { n as validateFixedRoute, r as eligibleTransportFailure, t as installPlannerRoute } from "./planner-route-B9z5GziX.js";
+import { createRequire } from "node:module";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { createHash, randomUUID } from "node:crypto";
+import { realpathSync } from "node:fs";
+import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { lstat, mkdir, readFile, readlink, rm, symlink, writeFile } from "node:fs/promises";
+import { setSandboxMode } from "@deepseek-ai/dsh-sandbox-policy";
+import { createUserMessage } from "@deepseek-ai/dsh-llm";
+import { fileURLToPath } from "node:url";
+import { z } from "zod";
+//#region node_modules/@deepseek-ai/cosmokit/lib/index.js
+/** Return true when a value is `null` or `undefined`. */
+function isNullable(value) {
+	return value === null || value === void 0;
+}
+/** Return true for non-array object values. */
+function isPlainObject(data) {
+	return data && typeof data === "object" && !Array.isArray(data);
+}
+/** Filter object entries and return a new object. */
+function filterKeys(object, filter) {
+	return Object.fromEntries(Object.entries(object).filter(([key, value]) => filter(key, value)));
+}
+/** Map object values while preserving the original key set. */
+function mapValues(object, transform) {
+	return Object.fromEntries(Object.entries(object).map(([key, value]) => [key, transform(value, key)]));
+}
+/** Pick selected keys from an object, optionally including `undefined` values. */
+function pick(source, keys, forced) {
+	if (!keys) return { ...source };
+	const result = {};
+	for (const key of keys) if (forced || source[key] !== void 0) result[key] = source[key];
+	return result;
+}
+/** Test values using `instanceof` with a `toStringTag` fallback. */
+function is(type, value) {
+	if (arguments.length === 1) return (value) => is(type, value);
+	return type in globalThis && value instanceof globalThis[type] || Object.prototype.toString.call(value).slice(8, -1) === type;
+}
+function isArrayBufferLike(value) {
+	return is("ArrayBuffer", value) || is("SharedArrayBuffer", value);
+}
+function isArrayBufferSource(value) {
+	return isArrayBufferLike(value) || ArrayBuffer.isView(value);
+}
+/** Binary source detection and base64/hex conversion helpers. */
+var Binary;
+(function(Binary) {
+	Binary.is = isArrayBufferLike;
+	Binary.isSource = isArrayBufferSource;
+	function fromSource(source) {
+		if (ArrayBuffer.isView(source)) return source.buffer.slice(source.byteOffset, source.byteOffset + source.byteLength);
+		else return source;
+	}
+	Binary.fromSource = fromSource;
+	function toBase64(source) {
+		source = fromSource(source);
+		if (typeof Buffer !== "undefined") return Buffer.from(source).toString("base64");
+		let binary = "";
+		const bytes = new Uint8Array(source);
+		for (let i = 0; i < bytes.byteLength; i++) binary += String.fromCharCode(bytes[i]);
+		return btoa(binary);
+	}
+	Binary.toBase64 = toBase64;
+	function fromBase64(source) {
+		if (typeof Buffer !== "undefined") return fromSource(Buffer.from(source, "base64"));
+		return Uint8Array.from(atob(source), (c) => c.charCodeAt(0));
+	}
+	Binary.fromBase64 = fromBase64;
+	function toHex(source) {
+		source = fromSource(source);
+		if (typeof Buffer !== "undefined") return Buffer.from(source).toString("hex");
+		return Array.from(new Uint8Array(source), (byte) => byte.toString(16).padStart(2, "0")).join("");
+	}
+	Binary.toHex = toHex;
+	function fromHex(source) {
+		if (typeof Buffer !== "undefined") return fromSource(Buffer.from(source, "hex"));
+		const hex = source.length % 2 === 0 ? source : source.slice(0, source.length - 1);
+		const buffer = [];
+		for (let i = 0; i < hex.length; i += 2) buffer.push(parseInt(`${hex[i]}${hex[i + 1]}`, 16));
+		return Uint8Array.from(buffer).buffer;
+	}
+	Binary.fromHex = fromHex;
+})(Binary || (Binary = {}));
+Binary.fromBase64;
+Binary.toBase64;
+Binary.fromHex;
+Binary.toHex;
+/** Deep-clone common JavaScript values while preserving prototypes and cycles. */
+function clone(source, refs = /* @__PURE__ */ new Map()) {
+	if (!source || typeof source !== "object") return source;
+	if (is("Date", source)) return new Date(source.valueOf());
+	if (is("RegExp", source)) return new RegExp(source.source, source.flags);
+	if (isArrayBufferLike(source)) return source.slice(0);
+	if (ArrayBuffer.isView(source)) return source.buffer.slice(source.byteOffset, source.byteOffset + source.byteLength);
+	const cached = refs.get(source);
+	if (cached) return cached;
+	if (Array.isArray(source)) {
+		const result = [];
+		refs.set(source, result);
+		source.forEach((value, index) => {
+			result[index] = Reflect.apply(clone, null, [value, refs]);
+		});
+		return result;
+	}
+	const result = Object.create(Object.getPrototypeOf(source));
+	refs.set(source, result);
+	for (const key of Reflect.ownKeys(source)) {
+		const descriptor = { ...Reflect.getOwnPropertyDescriptor(source, key) };
+		if ("value" in descriptor) descriptor.value = Reflect.apply(clone, null, [descriptor.value, refs]);
+		Reflect.defineProperty(result, key, descriptor);
+	}
+	return result;
+}
+/** Deeply compare arrays, dates, regexps, buffers, and plain object fields. */
+function deepEqual(a, b, strict) {
+	if (a === b) return true;
+	if (!strict && isNullable(a) && isNullable(b)) return true;
+	if (typeof a !== typeof b) return false;
+	if (typeof a !== "object") return false;
+	if (!a || !b) return false;
+	function check(test, then) {
+		return test(a) ? test(b) ? then(a, b) : false : test(b) ? false : void 0;
+	}
+	return check(Array.isArray, (a, b) => a.length === b.length && a.every((item, index) => deepEqual(item, b[index]))) ?? check(is("Date"), (a, b) => a.valueOf() === b.valueOf()) ?? check(is("RegExp"), (a, b) => a.source === b.source && a.flags === b.flags) ?? check(isArrayBufferLike, (a, b) => {
+		if (a.byteLength !== b.byteLength) return false;
+		const viewA = new Uint8Array(a);
+		const viewB = new Uint8Array(b);
+		for (let i = 0; i < viewA.length; i++) if (viewA[i] !== viewB[i]) return false;
+		return true;
+	}) ?? Object.keys({
+		...a,
+		...b
+	}).every((key) => deepEqual(a[key], b[key], strict));
+}
+/** Time constants plus parsing and formatting helpers. */
+var Time;
+(function(Time) {
+	Time.millisecond = 1;
+	Time.second = 1e3;
+	Time.minute = Time.second * 60;
+	Time.hour = Time.minute * 60;
+	Time.day = Time.hour * 24;
+	Time.week = Time.day * 7;
+	let timezoneOffset = (/* @__PURE__ */ new Date()).getTimezoneOffset();
+	function setTimezoneOffset(offset) {
+		timezoneOffset = offset;
+	}
+	Time.setTimezoneOffset = setTimezoneOffset;
+	function getTimezoneOffset() {
+		return timezoneOffset;
+	}
+	Time.getTimezoneOffset = getTimezoneOffset;
+	function getDateNumber(date = /* @__PURE__ */ new Date(), offset) {
+		if (typeof date === "number") date = new Date(date);
+		if (offset === void 0) offset = timezoneOffset;
+		return Math.floor((date.valueOf() / Time.minute - offset) / 1440);
+	}
+	Time.getDateNumber = getDateNumber;
+	function fromDateNumber(value, offset) {
+		const date = new Date(value * Time.day);
+		if (offset === void 0) offset = timezoneOffset;
+		return new Date(+date + offset * Time.minute);
+	}
+	Time.fromDateNumber = fromDateNumber;
+	const numeric = /\d+(?:\.\d+)?/.source;
+	const timeRegExp = new RegExp(`^${[
+		"w(?:eek(?:s)?)?",
+		"d(?:ay(?:s)?)?",
+		"h(?:our(?:s)?)?",
+		"m(?:in(?:ute)?(?:s)?)?",
+		"s(?:ec(?:ond)?(?:s)?)?"
+	].map((unit) => `(${numeric}${unit})?`).join("")}$`);
+	function parseTime(source) {
+		const capture = timeRegExp.exec(source);
+		if (!capture) return 0;
+		return (parseFloat(capture[1]) * Time.week || 0) + (parseFloat(capture[2]) * Time.day || 0) + (parseFloat(capture[3]) * Time.hour || 0) + (parseFloat(capture[4]) * Time.minute || 0) + (parseFloat(capture[5]) * Time.second || 0);
+	}
+	Time.parseTime = parseTime;
+	function parseDate(date) {
+		const parsed = parseTime(date);
+		if (parsed) date = Date.now() + parsed;
+		else if (/^\d{1,2}(:\d{1,2}){1,2}$/.test(date)) date = `${(/* @__PURE__ */ new Date()).toLocaleDateString()}-${date}`;
+		else if (/^\d{1,2}-\d{1,2}-\d{1,2}(:\d{1,2}){1,2}$/.test(date)) date = `${(/* @__PURE__ */ new Date()).getFullYear()}-${date}`;
+		return date ? new Date(date) : /* @__PURE__ */ new Date();
+	}
+	Time.parseDate = parseDate;
+	function format(ms) {
+		const abs = Math.abs(ms);
+		if (abs >= Time.day - Time.hour / 2) return Math.round(ms / Time.day) + "d";
+		else if (abs >= Time.hour - Time.minute / 2) return Math.round(ms / Time.hour) + "h";
+		else if (abs >= Time.minute - Time.second / 2) return Math.round(ms / Time.minute) + "m";
+		else if (abs >= Time.second) return Math.round(ms / Time.second) + "s";
+		return ms + "ms";
+	}
+	Time.format = format;
+	function toDigits(source, length = 2) {
+		return source.toString().padStart(length, "0");
+	}
+	Time.toDigits = toDigits;
+	function template(template, time = /* @__PURE__ */ new Date()) {
+		return template.replace("yyyy", time.getFullYear().toString()).replace("yy", time.getFullYear().toString().slice(2)).replace("MM", toDigits(time.getMonth() + 1)).replace("dd", toDigits(time.getDate())).replace("hh", toDigits(time.getHours())).replace("mm", toDigits(time.getMinutes())).replace("ss", toDigits(time.getSeconds())).replace("SSS", toDigits(time.getMilliseconds(), 3));
+	}
+	Time.template = template;
+})(Time || (Time = {}));
+//#endregion
+//#region node_modules/@deepseek-ai/schemastery/lib/index.mjs
+const kSchema = Symbol.for("schemastery");
+const kValidationError = Symbol.for("ValidationError");
+globalThis.__schemastery_index__ ??= 0;
+globalThis.__schemastery_refs__ = void 0;
+var ValidationError = class extends TypeError {
+	options;
+	name = "ValidationError";
+	constructor(message, options) {
+		let prefix = "$";
+		for (const segment of options.path || []) if (typeof segment === "string") prefix += "." + segment;
+		else if (typeof segment === "number") prefix += "[" + segment + "]";
+		else if (typeof segment === "symbol") prefix += `[Symbol(${segment.toString()})]`;
+		if (prefix.startsWith(".")) prefix = prefix.slice(1);
+		super((prefix === "$" ? "" : `${prefix} `) + message);
+		this.options = options;
+	}
+	static is(error) {
+		return !!error?.[kValidationError];
+	}
+};
+Object.defineProperty(ValidationError.prototype, kValidationError, { value: true });
+const Schema = function(options) {
+	const schema = function(data, options = {}) {
+		return Schema.resolve(data, schema, options)[0];
+	};
+	if (options.refs) {
+		const refs = mapValues(options.refs, (options) => new Schema(options));
+		const getRef = (uid) => refs[uid];
+		for (const key in refs) {
+			const options = refs[key];
+			options.sKey = getRef(options.sKey);
+			options.inner = getRef(options.inner);
+			options.list = options.list && options.list.map(getRef);
+			options.dict = options.dict && mapValues(options.dict, getRef);
+		}
+		return refs[options.uid];
+	}
+	Object.assign(schema, options);
+	if (typeof schema.callback === "string") try {
+		schema.callback = new Function("return " + schema.callback)();
+	} catch {}
+	Object.defineProperty(schema, "uid", { value: globalThis.__schemastery_index__++ });
+	Object.setPrototypeOf(schema, Schema.prototype);
+	schema.meta ||= {};
+	schema.toString = schema.toString.bind(schema);
+	return schema;
+};
+Schema.prototype = Object.create(Function.prototype);
+Schema.prototype[kSchema] = true;
+Object.defineProperty(Schema.prototype, "~standard", { get() {
+	return {
+		version: 1,
+		vendor: "schemastery",
+		validate: (value) => {
+			try {
+				return { value: Schema.resolve(value, this, {})[0] };
+			} catch (error) {
+				if (ValidationError.is(error)) return { issues: [{
+					message: error.message,
+					path: error.options.path
+				}] };
+				throw error;
+			}
+		}
+	};
+} });
+Schema.ValidationError = ValidationError;
+Schema.prototype.toJSON = function toJSON() {
+	if (globalThis.__schemastery_refs__) {
+		globalThis.__schemastery_refs__[this.uid] ??= JSON.parse(JSON.stringify({ ...this }));
+		return this.uid;
+	}
+	globalThis.__schemastery_refs__ = { [this.uid]: { ...this } };
+	globalThis.__schemastery_refs__[this.uid] = JSON.parse(JSON.stringify({ ...this }));
+	const result = {
+		uid: this.uid,
+		refs: globalThis.__schemastery_refs__
+	};
+	globalThis.__schemastery_refs__ = void 0;
+	return result;
+};
+Schema.prototype.set = function set(key, value) {
+	this.dict[key] = value;
+	return this;
+};
+Schema.prototype.push = function push(value) {
+	this.list.push(value);
+	return this;
+};
+function mergeDesc(original, messages) {
+	const result = typeof original === "string" ? { "": original } : { ...original };
+	for (const locale in messages) {
+		const value = messages[locale];
+		if (value?.$description || value?.$desc) result[locale] = value.$description || value.$desc;
+		else if (typeof value === "string") result[locale] = value;
+	}
+	return result;
+}
+function getInner(value) {
+	return value?.$value ?? value?.$inner;
+}
+function extractKeys(data) {
+	return filterKeys(data ?? {}, (key) => !key.startsWith("$"));
+}
+Schema.prototype.i18n = function i18n(messages) {
+	const schema = Schema(this);
+	const desc = mergeDesc(schema.meta.description, messages);
+	if (Object.keys(desc).length) schema.meta.description = desc;
+	if (schema.dict) schema.dict = mapValues(schema.dict, (inner, key) => {
+		return inner.i18n(mapValues(messages, (data) => getInner(data)?.[key] ?? data?.[key]));
+	});
+	if (schema.list) schema.list = schema.list.map((inner, index) => {
+		return inner.i18n(mapValues(messages, (data = {}) => {
+			if (Array.isArray(getInner(data))) return getInner(data)[index];
+			if (Array.isArray(data)) return data[index];
+			return extractKeys(data);
+		}));
+	});
+	if (schema.inner) schema.inner = schema.inner.i18n(mapValues(messages, (data) => {
+		if (getInner(data)) return getInner(data);
+		return extractKeys(data);
+	}));
+	if (schema.sKey) schema.sKey = schema.sKey.i18n(mapValues(messages, (data) => data?.$key));
+	return schema;
+};
+Schema.prototype.extra = function extra(key, value) {
+	const schema = Schema(this);
+	schema.meta = {
+		...schema.meta,
+		[key]: value
+	};
+	return schema;
+};
+for (const key of [
+	"required",
+	"disabled",
+	"collapse",
+	"hidden",
+	"loose"
+]) Object.assign(Schema.prototype, { [key](value = true) {
+	const schema = Schema(this);
+	schema.meta = {
+		...schema.meta,
+		[key]: value
+	};
+	return schema;
+} });
+Schema.prototype.deprecated = function deprecated() {
+	const schema = Schema(this);
+	schema.meta.badges ||= [];
+	schema.meta.badges.push({
+		text: "deprecated",
+		type: "danger"
+	});
+	return schema;
+};
+Schema.prototype.experimental = function experimental() {
+	const schema = Schema(this);
+	schema.meta.badges ||= [];
+	schema.meta.badges.push({
+		text: "experimental",
+		type: "warning"
+	});
+	return schema;
+};
+Schema.prototype.pattern = function pattern(regexp) {
+	const schema = Schema(this);
+	const pattern = pick(regexp, ["source", "flags"]);
+	schema.meta = {
+		...schema.meta,
+		pattern
+	};
+	return schema;
+};
+Schema.prototype.simplify = function simplify(value) {
+	if (deepEqual(value, this.meta.default, this.type === "dict")) return null;
+	if (isNullable(value)) return value;
+	if (this.type === "object" || this.type === "dict") {
+		const result = {};
+		for (const key in value) {
+			const item = (this.type === "object" ? this.dict[key] : this.inner)?.simplify(value[key]);
+			if (this.type === "dict" || !isNullable(item)) result[key] = item;
+		}
+		if (deepEqual(result, this.meta.default, this.type === "dict")) return null;
+		return result;
+	} else if (this.type === "array" || this.type === "tuple") {
+		const result = [];
+		value.forEach((value, index) => {
+			const schema = this.type === "array" ? this.inner : this.list[index];
+			const item = schema ? schema.simplify(value) : value;
+			result.push(item);
+		});
+		return result;
+	} else if (this.type === "intersect") {
+		const result = {};
+		for (const item of this.list) Object.assign(result, item.simplify(value));
+		return result;
+	} else if (this.type === "union") for (const schema of this.list) try {
+		Schema.resolve(value, schema, {});
+		return schema.simplify(value);
+	} catch {}
+	return value;
+};
+Schema.prototype.toString = function toString(inline) {
+	return formatters[this.type]?.(this, inline) ?? `Schema<${this.type}>`;
+};
+Schema.prototype.role = function role(role, extra) {
+	const schema = Schema(this);
+	schema.meta = {
+		...schema.meta,
+		role,
+		extra
+	};
+	return schema;
+};
+for (const key of [
+	"default",
+	"link",
+	"comment",
+	"description",
+	"max",
+	"min",
+	"step"
+]) Object.assign(Schema.prototype, { [key](value) {
+	const schema = Schema(this);
+	schema.meta = {
+		...schema.meta,
+		[key]: value
+	};
+	return schema;
+} });
+const resolvers = {};
+Schema.extend = function extend(type, resolve) {
+	resolvers[type] = resolve;
+};
+Schema.resolve = function resolve(data, schema, options = {}, strict = false) {
+	if (!schema) return [data];
+	if (options.ignore?.(data, schema)) return [data];
+	if (isNullable(data) && schema.type !== "lazy") {
+		if (schema.meta.required) throw new ValidationError(`missing required value`, options);
+		let current = schema;
+		let fallback = schema.meta.default;
+		while (current?.type === "intersect" && isNullable(fallback)) {
+			current = current.list[0];
+			fallback = current?.meta.default;
+		}
+		if (isNullable(fallback)) return [data];
+		data = clone(fallback);
+	}
+	const callback = resolvers[schema.type];
+	if (!callback) throw new ValidationError(`unsupported type "${schema.type}"`, options);
+	try {
+		return callback(data, schema, options, strict);
+	} catch (error) {
+		if (!schema.meta.loose) throw error;
+		return [schema.meta.default];
+	}
+};
+Schema.from = function from(source) {
+	if (isNullable(source)) return Schema.any();
+	else if ([
+		"string",
+		"number",
+		"boolean"
+	].includes(typeof source)) return Schema.const(source).required();
+	else if (source[kSchema]) return source;
+	else if (typeof source === "function") switch (source) {
+		case String: return Schema.string().required();
+		case Number: return Schema.number().required();
+		case Boolean: return Schema.boolean().required();
+		case Function: return Schema.function().required();
+		default: return Schema.is(source).required();
+	}
+	else throw new TypeError(`cannot infer schema from ${source}`);
+};
+Schema.lazy = function lazy(builder) {
+	const toJSON = () => {
+		if (!schema.inner[kSchema]) {
+			schema.inner = schema.builder();
+			schema.inner.meta = {
+				...schema.meta,
+				...schema.inner.meta
+			};
+		}
+		return schema.inner.toJSON();
+	};
+	const schema = new Schema({
+		type: "lazy",
+		builder,
+		inner: { toJSON }
+	});
+	return schema;
+};
+Schema.natural = function natural() {
+	return Schema.number().step(1).min(0);
+};
+Schema.percent = function percent() {
+	return Schema.number().step(.01).min(0).max(1).role("slider");
+};
+Schema.date = function date() {
+	return Schema.union([Schema.is(Date), Schema.transform(Schema.string().role("datetime"), (value, options) => {
+		const date = new Date(value);
+		if (isNaN(+date)) throw new ValidationError(`invalid date "${value}"`, options);
+		return date;
+	}, true)]);
+};
+Schema.regExp = function regExp(flag = "") {
+	return Schema.union([Schema.is(RegExp), Schema.transform(Schema.string().role("regexp", { flag }), (value, options) => {
+		try {
+			return new RegExp(value, flag);
+		} catch (e) {
+			throw new ValidationError(e.message, options);
+		}
+	}, true)]);
+};
+Schema.arrayBuffer = function arrayBuffer(encoding) {
+	return Schema.union([
+		Schema.is(ArrayBuffer),
+		Schema.is(SharedArrayBuffer),
+		Schema.transform(Schema.any(), (value, options) => {
+			if (Binary.isSource(value)) return Binary.fromSource(value);
+			throw new ValidationError(`expected ArrayBufferSource but got ${value}`, options);
+		}, true),
+		...encoding ? [Schema.transform(Schema.string(), (value, options) => {
+			try {
+				return encoding === "base64" ? Binary.fromBase64(value) : Binary.fromHex(value);
+			} catch (e) {
+				throw new ValidationError(e.message, options);
+			}
+		}, true)] : []
+	]);
+};
+Schema.extend("lazy", (data, schema, options, strict) => {
+	if (!schema.inner[kSchema]) {
+		schema.inner = schema.builder();
+		schema.inner.meta = {
+			...schema.meta,
+			...schema.inner.meta
+		};
+	}
+	return Schema.resolve(data, schema.inner, options, strict);
+});
+Schema.extend("any", (data) => {
+	return [data];
+});
+Schema.extend("never", (data, _, options) => {
+	throw new ValidationError(`expected nullable but got ${data}`, options);
+});
+Schema.extend("const", (data, { value }, options) => {
+	if (deepEqual(data, value)) return [value];
+	throw new ValidationError(`expected ${value} but got ${data}`, options);
+});
+function checkWithinRange(data, meta, description, options, skipMin = false) {
+	const { max = Infinity, min = -Infinity } = meta;
+	if (data > max) throw new ValidationError(`expected ${description} <= ${max} but got ${data}`, options);
+	if (data < min && !skipMin) throw new ValidationError(`expected ${description} >= ${min} but got ${data}`, options);
+}
+Schema.extend("string", (data, { meta }, options) => {
+	if (typeof data !== "string") throw new ValidationError(`expected string but got ${data}`, options);
+	if (meta.pattern) {
+		const regexp = new RegExp(meta.pattern.source, meta.pattern.flags);
+		if (!regexp.test(data)) throw new ValidationError(`expect string to match regexp ${regexp}`, options);
+	}
+	checkWithinRange(data.length, meta, "string length", options);
+	return [data];
+});
+function decimalShift(data, digits) {
+	const str = data.toString();
+	if (str.includes("e")) return data * Math.pow(10, digits);
+	const index = str.indexOf(".");
+	if (index === -1) return data * Math.pow(10, digits);
+	const frac = str.slice(index + 1);
+	const integer = str.slice(0, index);
+	if (frac.length <= digits) return +(integer + frac.padEnd(digits, "0"));
+	return +(integer + frac.slice(0, digits) + "." + frac.slice(digits));
+}
+function isMultipleOf(data, min, step) {
+	step = Math.abs(step);
+	if (!/^\d+\.\d+$/.test(step.toString())) return (data - min) % step === 0;
+	const index = step.toString().indexOf(".");
+	const digits = step.toString().slice(index + 1).length;
+	return Math.abs(decimalShift(data, digits) - decimalShift(min, digits)) % decimalShift(step, digits) === 0;
+}
+Schema.extend("number", (data, { meta }, options) => {
+	if (typeof data !== "number") throw new ValidationError(`expected number but got ${data}`, options);
+	checkWithinRange(data, meta, "number", options);
+	const { step } = meta;
+	if (step && !isMultipleOf(data, meta.min ?? 0, step)) throw new ValidationError(`expected number multiple of ${step} but got ${data}`, options);
+	return [data];
+});
+Schema.extend("boolean", (data, _, options) => {
+	if (typeof data === "boolean") return [data];
+	throw new ValidationError(`expected boolean but got ${data}`, options);
+});
+Schema.extend("bitset", (data, { bits, meta }, options) => {
+	let value = 0, keys = [];
+	if (typeof data === "number") {
+		value = data;
+		for (const key in bits) if (data & bits[key]) keys.push(key);
+	} else if (Array.isArray(data)) {
+		keys = data;
+		for (const key of keys) {
+			if (typeof key !== "string") throw new ValidationError(`expected string but got ${key}`, options);
+			if (key in bits) value |= bits[key];
+		}
+	} else throw new ValidationError(`expected number or array but got ${data}`, options);
+	if (value === meta.default) return [value];
+	return [value, keys];
+});
+Schema.extend("function", (data, _, options) => {
+	if (typeof data === "function") return [data];
+	throw new ValidationError(`expected function but got ${data}`, options);
+});
+Schema.extend("is", (data, { constructor }, options) => {
+	if (typeof constructor === "function") {
+		if (data instanceof constructor) return [data];
+		throw new ValidationError(`expected ${constructor.name} but got ${data}`, options);
+	} else {
+		if (isNullable(data)) throw new ValidationError(`expected ${constructor} but got ${data}`, options);
+		let prototype = Object.getPrototypeOf(data);
+		while (prototype) {
+			if (prototype.constructor?.name === constructor) return [data];
+			prototype = Object.getPrototypeOf(prototype);
+		}
+		throw new ValidationError(`expected ${constructor} but got ${data}`, options);
+	}
+});
+function property(data, key, schema, options) {
+	try {
+		const [value, adapted] = Schema.resolve(data[key], schema, {
+			...options,
+			path: [...options.path || [], key]
+		});
+		if (adapted !== void 0) data[key] = adapted;
+		return value;
+	} catch (e) {
+		if (!options?.autofix) throw e;
+		delete data[key];
+		return schema.meta.default;
+	}
+}
+Schema.extend("array", (data, { inner, meta }, options) => {
+	if (!Array.isArray(data)) throw new ValidationError(`expected array but got ${data}`, options);
+	checkWithinRange(data.length, meta, "array length", options, !isNullable(inner.meta.default));
+	return [data.map((_, index) => property(data, index, inner, options))];
+});
+Schema.extend("dict", (data, { inner, sKey }, options, strict) => {
+	if (!isPlainObject(data)) throw new ValidationError(`expected object but got ${data}`, options);
+	const result = {};
+	for (const key in data) {
+		let rKey;
+		try {
+			rKey = Schema.resolve(key, sKey, options)[0];
+		} catch (error) {
+			if (strict) continue;
+			throw error;
+		}
+		result[rKey] = property(data, key, inner, options);
+		data[rKey] = data[key];
+		if (key !== rKey) delete data[key];
+	}
+	return [result];
+});
+Schema.extend("tuple", (data, { list }, options, strict) => {
+	if (!Array.isArray(data)) throw new ValidationError(`expected array but got ${data}`, options);
+	const result = list.map((inner, index) => property(data, index, inner, options));
+	if (strict) return [result];
+	result.push(...data.slice(list.length));
+	return [result];
+});
+function merge(result, data) {
+	for (const key in data) {
+		if (key in result) continue;
+		result[key] = data[key];
+	}
+}
+Schema.extend("object", (data, { dict }, options, strict) => {
+	if (!isPlainObject(data)) throw new ValidationError(`expected object but got ${data}`, options);
+	const result = {};
+	for (const key in dict) {
+		const value = property(data, key, dict[key], options);
+		if (!isNullable(value) || key in data) result[key] = value;
+	}
+	if (!strict) merge(result, data);
+	return [result];
+});
+Schema.extend("union", (data, { list, toString }, options, strict) => {
+	const messages = [];
+	for (const inner of list) try {
+		return Schema.resolve(data, inner, options, strict);
+	} catch (error) {
+		messages.push(error);
+	}
+	throw new ValidationError(`expected ${toString()} but got ${JSON.stringify(data)}`, options);
+});
+Schema.extend("intersect", (data, { list, toString }, options, strict) => {
+	if (!list.length) return [data];
+	let result;
+	for (const inner of list) {
+		const value = Schema.resolve(data, inner, options, true)[0];
+		if (isNullable(value)) continue;
+		if (isNullable(result)) result = value;
+		else if (typeof result !== typeof value) throw new ValidationError(`expected ${toString()} but got ${JSON.stringify(data)}`, options);
+		else if (typeof value === "object") merge(result ??= {}, value);
+		else if (result !== value) throw new ValidationError(`expected ${toString()} but got ${JSON.stringify(data)}`, options);
+	}
+	if (!strict && isPlainObject(data)) merge(result, data);
+	return [result];
+});
+Schema.extend("transform", (data, { inner, callback, preserve }, options) => {
+	const [result, adapted = data] = Schema.resolve(data, inner, options, true);
+	if (preserve) return [callback(result)];
+	else return [callback(result), callback(adapted)];
+});
+const formatters = {};
+function defineMethod(name, keys, format) {
+	formatters[name] = format;
+	Object.assign(Schema, { [name](...args) {
+		const schema = new Schema({ type: name });
+		keys.forEach((key, index) => {
+			switch (key) {
+				case "sKey":
+					schema.sKey = args[index] ?? Schema.string();
+					break;
+				case "inner":
+					schema.inner = Schema.from(args[index]);
+					break;
+				case "list":
+					schema.list = args[index].map(Schema.from);
+					break;
+				case "dict":
+					schema.dict = mapValues(args[index], Schema.from);
+					break;
+				case "bits":
+					schema.bits = {};
+					for (const key in args[index]) {
+						if (typeof args[index][key] !== "number") continue;
+						schema.bits[key] = args[index][key];
+					}
+					break;
+				case "callback": {
+					const callback = schema.callback = args[index];
+					callback["toJSON"] ||= () => callback.toString();
+					break;
+				}
+				case "constructor": {
+					const constructor = schema.constructor = args[index];
+					if (typeof constructor === "function") constructor["toJSON"] ||= () => constructor["name"];
+					break;
+				}
+				default: schema[key] = args[index];
+			}
+		});
+		if (name === "object" || name === "dict") schema.meta.default = {};
+		else if (name === "array" || name === "tuple") schema.meta.default = [];
+		else if (name === "bitset") schema.meta.default = 0;
+		return schema;
+	} });
+}
+defineMethod("is", ["constructor"], ({ constructor }) => {
+	if (typeof constructor === "function") return constructor.name;
+	else return constructor;
+});
+defineMethod("any", [], () => "any");
+defineMethod("never", [], () => "never");
+defineMethod("const", ["value"], ({ value }) => typeof value === "string" ? JSON.stringify(value) : value);
+defineMethod("string", [], () => "string");
+defineMethod("number", [], () => "number");
+defineMethod("boolean", [], () => "boolean");
+defineMethod("bitset", ["bits"], () => "bitset");
+defineMethod("function", [], () => "function");
+defineMethod("array", ["inner"], ({ inner }) => `${inner.toString(true)}[]`);
+defineMethod("dict", ["inner", "sKey"], ({ inner, sKey }) => `{ [key: ${sKey.toString()}]: ${inner.toString()} }`);
+defineMethod("tuple", ["list"], ({ list }) => `[${list.map((inner) => inner.toString()).join(", ")}]`);
+defineMethod("object", ["dict"], ({ dict }) => {
+	if (Object.keys(dict).length === 0) return "{}";
+	return `{ ${Object.entries(dict).map(([key, inner]) => {
+		return `${key}${inner.meta.required ? "" : "?"}: ${inner.toString()}`;
+	}).join(", ")} }`;
+});
+defineMethod("union", ["list"], ({ list }, inline) => {
+	const result = list.map(({ toString: format }) => format()).join(" | ");
+	return inline ? `(${result})` : result;
+});
+defineMethod("intersect", ["list"], ({ list }) => {
+	return `${list.map((inner) => inner.toString(true)).join(" & ")}`;
+});
+defineMethod("transform", [
+	"inner",
+	"callback",
+	"preserve"
+], ({ inner }, isInner) => inner.toString(isInner));
+//#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: []
+});
+const DEFAULT_SETTINGS = 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
+	};
+}
+function mergeSettings(base, patch) {
+	const roles = {
+		...base.roles,
+		...patch.roles ?? {}
+	};
+	return validateSettings({
+		...base,
+		...patch,
+		roles,
+		planning: {
+			...base.planning,
+			...patch.planning ?? {}
+		},
+		execution: {
+			...base.execution,
+			...patch.execution ?? {}
+		},
+		review: {
+			...base.review,
+			...patch.review ?? {}
+		},
+		recovery: {
+			...base.recovery,
+			...patch.recovery ?? {}
+		},
+		externalIssue: {
+			...base.externalIssue,
+			...patch.externalIssue ?? {}
+		},
+		workspaceOverrides: {
+			...base.workspaceOverrides,
+			...patch.workspaceOverrides ?? {}
+		}
+	});
+}
+function effectiveRoleRoute(settings, role, workspaceKey) {
+	const global = settings.roles[role];
+	if (!workspaceKey) return structuredClone(global);
+	const override = settings.workspaceOverrides[workspaceKey]?.roles?.[role];
+	if (!override || override.mode === "inherit") return structuredClone(global);
+	return structuredClone({
+		...override,
+		mode: override.mode
+	});
+}
+//#endregion
+//#region src/settings-service.ts
+const settingsEnvelope = Schema.any().default(DEFAULT_SETTINGS);
+function canonicalWorkspaceIdentity(cwd) {
+	let canonical = resolve(cwd);
+	try {
+		canonical = realpathSync.native(canonical);
+	} catch {}
+	if (process.platform === "win32") canonical = canonical.toLocaleLowerCase("en-US");
+	return canonical;
+}
+function workspaceKey(cwd) {
+	return createHash("sha256").update(canonicalWorkspaceIdentity(cwd)).digest("base64url");
+}
+function registerSettings(ctx) {
+	const handle = ctx.settings.register(SETTINGS_NAMESPACE, settingsEnvelope, {
+		applies: "live",
+		validate: (value) => {
+			validateSettings(value);
+		}
+	});
+	const get = () => validateSettings(handle.get() ?? DEFAULT_SETTINGS);
+	const update = async (patch) => {
+		const next = mergeSettings(get(), patch);
+		await handle.update(next);
+	};
+	const effective = (cwd) => {
+		const value = get();
+		if (!cwd) return value;
+		const key = workspaceKey(cwd);
+		return {
+			...value,
+			roles: Object.fromEntries([
+				"planner",
+				"worker",
+				"integrator",
+				"reviewer"
+			].map((role) => [role, effectiveRoleRoute(value, role, key)]))
+		};
+	};
+	return {
+		get,
+		effective,
+		update,
+		watch: (fn) => handle.watch(() => fn(get())),
+		writable: () => Boolean(ctx.settings.writable)
+	};
+}
+//#endregion
+//#region src/planning/native-plan-bridge.ts
+var NativePlanBridge = class {
+	#staged = /* @__PURE__ */ new Map();
+	key(sessionId, toolCallId) {
+		return `${sessionId}\0${toolCallId}`;
+	}
+	stage(sessionId, toolCallId, plan, baselineHead, requireOwnership = true) {
+		const { artifact, hash } = extractPlanArtifact(plan, requireOwnership);
+		const staged = {
+			sessionId,
+			toolCallId,
+			plan,
+			artifact,
+			hash,
+			baselineHead,
+			stagedAt: (/* @__PURE__ */ new Date()).toISOString()
+		};
+		this.#staged.set(this.key(sessionId, toolCallId), staged);
+		return staged;
+	}
+	get(sessionId, toolCallId) {
+		return this.#staged.get(this.key(sessionId, toolCallId));
+	}
+	consume(sessionId, toolCallId) {
+		const key = this.key(sessionId, toolCallId), value = this.#staged.get(key);
+		if (value) this.#staged.delete(key);
+		return value;
+	}
+	clearSession(sessionId) {
+		for (const [k, v] of this.#staged) if (v.sessionId === sessionId) this.#staged.delete(k);
+	}
+};
+function installExitPlanValidator(ctx, bridge, requireOwnership, isEnabled = () => true) {
+	return ctx.on("tools/pre-execute", async (exec, next) => {
+		if (exec.name !== "exit_plan_mode") return next();
+		if (!isEnabled(exec.agent)) return next();
+		const agent = exec.agent;
+		const sessionId = String(agent?.session?.id ?? "");
+		if (!sessionId) return {
+			kind: "deny",
+			reason: "Plan Orchestrator: exit_plan_mode has no calling session."
+		};
+		try {
+			const head = await fullHead(await repoRoot(agent.session.header?.cwd ?? process.cwd()));
+			bridge.stage(sessionId, String(exec.callId ?? ""), String(exec.arguments?.plan ?? ""), head, requireOwnership());
+		} catch (error) {
+			return {
+				kind: "deny",
+				reason: `Plan Orchestrator: invalid executable PlanArtifact/preflight: ${error.message}`
+			};
+		}
+		return next();
+	});
+}
+/** rc.1 exit_plan_mode succeeds only with the structured { approved: true } output. */
+function isNativePlanApproved(result) {
+	if (!result || typeof result !== "object") return false;
+	const value = result;
+	if (value.isError) return false;
+	return typeof value.value === "object" && value.value !== null && value.value.approved === true;
+}
+/**
+* Every settled native exit consumes its staged candidate. Runtime disable is
+* checked before returning an approved artifact so toggling Enabled OFF while
+* the native approval UI is open can never produce a delayed handoff.
+*/
+function consumeApprovedPlanResult(bridge, exec, result, isEnabled = () => true) {
+	if (exec?.name !== "exit_plan_mode") return void 0;
+	const sessionId = String(exec.agent?.session?.id ?? "");
+	const callId = String(exec.callId ?? "");
+	const staged = bridge.consume(sessionId, callId);
+	if (!isEnabled(exec.agent) || !staged || !isNativePlanApproved(result)) return void 0;
+	return staged;
+}
+//#endregion
+//#region src/planning/policy.ts
+const PLANNER_POLICY = `# Plan Orchestrator Contract
+You are the Planner. Plan mode is research-and-design only; do not mutate repository files.
+
+## Evidence before plan
+Classify claims as Verified Fact, Needs Verification, Recommendation, or Decision Lock. Never invent paths, APIs, commands, tests, dependencies, or runtime behavior.
+
+## Decisions and scope
+Prefer minimal sufficient architecture. No scope creep or speculative refactors. Ask the user only for product choices that cannot be discovered from the repository. A material unanswered choice blocks an executable plan. A Decision Lock may change only after new verified evidence and must record Previous Decision → New Evidence → Impact → Replacement Decision.
+
+## Tasks
+Split by responsibility, not arbitrary size. Every task has exact repository-relative modify[] ownership, acceptance, validation, dependsOn, and parallelSafe. Mark parallelSafe true only after checking shared APIs, schemas, types, config, migrations, generated output, mutable state, signatures, fixtures, and ordering; uncertainty means false.
+
+## Host validation safety
+validationCommands are not an arbitrary shell. Use only an existing package.json script through npm/pnpm/yarn/bun: \`<manager> test\` or \`<manager> run <script>\`; optional script arguments must follow \`--\`. Never emit curl/wget/npx, inline node/python/powershell, pipes, redirection, command substitution, chained shell commands, or an executable not represented by an existing package script.
+
+## Final gates
+Before exit_plan_mode: Scope, Evidence, Decision Stability, Task Boundaries, Add-When-Needed, Acceptance & Validation, Packet & Context Efficiency, Execution & Review Readiness must all pass.
+The Markdown plan MUST contain exactly one \`\`\`json fence with a strict PlanArtifact version 1. Do not emit an executable PlanArtifact if unresolved evidence can change architecture/ownership/user-visible behavior/acceptance.`;
+function researchPolicy(planning) {
+	const lines = ["## Research budget"];
+	if (planning.adaptiveResearch) lines.push("Research depth is adaptive: if evidence is sufficient, stop; otherwise identify the smallest missing evidence that can change architecture, ownership, user-visible behavior, or acceptance, verify only that gap, then reassess.");
+	else lines.push("Adaptive research is disabled: perform one bounded verification pass and stop unless a missing fact makes an executable plan unsafe.");
+	lines.push(`Initial read budget: at most ${planning.maxInitialReadFiles} files before reassessing evidence sufficiency.`);
+	lines.push(`Soft Planner input budget: ${planning.softInputTokens} tokens. Treat this as a stop/reassess threshold, not permission to omit required evidence.`);
+	if (planning.progressiveDiscovery) lines.push(planning.requireExpansionReason ? "Progressive discovery is allowed only for a concrete blocker; record the expansion reason before reading beyond the initial targets." : "Progressive discovery is allowed for evidence gaps, but expand incrementally and stop when the gap is closed.");
+	else lines.push("Progressive discovery is disabled: do not expand beyond the initial read set; if evidence remains insufficient, report the blocker instead of guessing.");
+	lines.push("No-progress research stops with an explicit missing-evidence report.");
+	return lines.join("\n");
+}
+const COMPACT_PLANNER_REMINDER = "Plan Mode remains active: evidence-before-plan, Decision Locks, exact modify[] ownership, configured research budget, strict PlanArtifact v1, package-script-only host validation, no repository mutation.";
+function plannerPolicyText(enabled, active, first, planning) {
+	if (!enabled || !active) return "";
+	if (!first) return COMPACT_PLANNER_REMINDER;
+	if (!planning) return PLANNER_POLICY;
+	return `${PLANNER_POLICY}\n\n${researchPolicy(planning)}`;
+}
+//#endregion
+//#region src/planning/read-only-guard.ts
+const MUTATION_NAMES = /^(write|write_file|edit|edit_file|apply_patch|patch|delete|move|rename|mkdir|bash|pwsh|shell|run_code)$/i;
+var PlannerReadOnlyGuard = class {
+	#active = /* @__PURE__ */ new Map();
+	#degraded = /* @__PURE__ */ new Map();
+	activate(session, sandboxPolicy) {
+		const sid = String(session.id);
+		if (this.#active.has(sid)) return;
+		try {
+			const previousEffective = sandboxPolicy.resolve({ session }).mode, previousOverride = sandboxPolicy.overrideOf(session);
+			setSandboxMode(session, "read-only");
+			const markerCount = this.modeEvents(session).length;
+			this.#active.set(sid, {
+				previousEffective,
+				previousOverride,
+				markerCount
+			});
+		} catch (e) {
+			this.#degraded.set(sid, `sandbox override unavailable: ${e.message}`);
+			this.#active.set(sid, {
+				previousEffective: "read-only",
+				markerCount: -1
+			});
+		}
+	}
+	deactivate(session, sandboxPolicy) {
+		const sid = String(session.id), owned = this.#active.get(sid);
+		if (!owned) return;
+		this.#active.delete(sid);
+		try {
+			if (owned.markerCount < 0) return;
+			const events = this.modeEvents(session);
+			const last = events.at(-1);
+			if (!(events.length === owned.markerCount && last?.data?.mode === "read-only")) return;
+			const target = owned.previousOverride ?? owned.previousEffective;
+			if (sandboxPolicy.resolve({ session }).mode === "read-only") setSandboxMode(session, target);
+		} catch (e) {
+			this.#degraded.set(sid, `sandbox restore skipped: ${e.message}`);
+		}
+	}
+	active(sessionId) {
+		return this.#active.has(sessionId);
+	}
+	degraded(sessionId) {
+		return this.#degraded.get(sessionId);
+	}
+	markDegraded(sessionId, reason) {
+		this.#degraded.set(sessionId, reason);
+	}
+	install(ctx, isEnabled = () => true) {
+		return ctx.on("tools/pre-execute", async (exec, next) => {
+			if (!isEnabled(exec.agent)) return next();
+			const sid = String(exec.agent?.session?.id ?? "");
+			if (!this.active(sid)) return next();
+			if (MUTATION_NAMES.test(String(exec.name))) return {
+				kind: "deny",
+				reason: "Plan Mode is strict read-only; repository mutation is blocked until approval."
+			};
+			return next();
+		});
+	}
+	modeEvents(session) {
+		return (session.snapshotEvents?.() ?? []).filter((e) => e.type === "sandbox/mode");
+	}
+};
+//#endregion
+//#region src/contract/events.ts
+function isPlanxEvent(event) {
+	return Boolean(event && typeof event.type === "string" && event.type.startsWith("planx/") && event.data && typeof event.data.runId === "string");
+}
+function reducePlanxEvents(sessionId, events) {
+	const rows = /* @__PURE__ */ new Map();
+	for (const event of events) {
+		if (!isPlanxEvent(event)) continue;
+		const d = event.data;
+		let v = rows.get(d.runId);
+		if (event.type === "planx/run-approved") {
+			v = {
+				runId: d.runId,
+				sessionId: String(d.sessionId ?? sessionId),
+				phase: "APPROVED_PENDING",
+				status: "APPROVED_PENDING",
+				tasksTotal: d.tasksTotal,
+				tasksDone: 0,
+				activeTaskIds: [],
+				reviewRound: 0,
+				startedAt: d.at,
+				updatedAt: d.at
+			};
+			rows.set(d.runId, v);
+			continue;
+		}
+		if (!v) continue;
+		if (event.type === "planx/run-phase") {
+			v.phase = d.phase;
+			v.status = d.phase;
+			if (d.message) v.message = d.message;
+		} else if (event.type === "planx/task-start") {
+			if (!v.activeTaskIds.includes(d.taskId)) v.activeTaskIds.push(d.taskId);
+		} else if (event.type === "planx/task-end") {
+			v.activeTaskIds = v.activeTaskIds.filter((x) => x !== d.taskId);
+			v.tasksDone = Math.min(v.tasksTotal, v.tasksDone + 1);
+		} else if (event.type === "planx/review") v.reviewRound = d.round;
+		else if (event.type === "planx/recovery") {
+			v.status = d.status;
+			if (d.message) v.message = d.message;
+		} else if (event.type === "planx/run-terminal") {
+			v.phase = d.phase;
+			v.status = d.phase;
+			v.activeTaskIds = [];
+			if (d.message) v.message = d.message;
+		}
+		v.updatedAt = d.at;
+	}
+	return [...rows.values()].sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+}
+//#endregion
+//#region src/git/fingerprints.ts
+async function fingerprintPath(root, path) {
+	const abs = join(root, path);
+	try {
+		const st = await lstat(abs);
+		if (st.isSymbolicLink()) return {
+			kind: "symlink",
+			target: await readlink(abs)
+		};
+		if (!st.isFile()) throw new Error(`owned path is not a regular file: ${path}`);
+		const bytes = await readFile(abs);
+		return {
+			kind: "file",
+			sha256: createHash("sha256").update(bytes).digest("hex"),
+			bytes: bytes.length
+		};
+	} catch (error) {
+		if (error?.code === "ENOENT") return { kind: "missing" };
+		throw error;
+	}
+}
+async function snapshotDirty(root) {
+	const head = await fullHead(root);
+	const paths = {};
+	for (const path of (await changedPaths(root)).sort()) paths[path] = await fingerprintPath(root, path);
+	return {
+		head,
+		paths
+	};
+}
+async function ownedFingerprint(root, paths) {
+	const values = [];
+	for (const path of [...new Set(paths)].sort()) values.push([path, await fingerprintPath(root, path)]);
+	return createHash("sha256").update(JSON.stringify(values)).digest("hex");
+}
+function deltaPaths(before, after) {
+	if (before.head !== after.head) throw new Error(`HEAD drift: ${before.head} -> ${after.head}`);
+	return [.../* @__PURE__ */ new Set([...Object.keys(before.paths), ...Object.keys(after.paths)])].filter((key) => JSON.stringify(before.paths[key] ?? { kind: "clean" }) !== JSON.stringify(after.paths[key] ?? { kind: "clean" })).sort();
+}
+function snapshotHash(snapshot) {
+	return createHash("sha256").update(JSON.stringify(snapshot)).digest("hex");
+}
+//#endregion
+//#region src/recovery/reconcile.ts
+async function diagnoseResume(repo, manifest, checkpoint) {
+	if (manifest.terminal) return {
+		resumable: false,
+		reason: "run is terminal"
+	};
+	if (await fullHead(repo) !== checkpoint.head) return {
+		resumable: false,
+		reason: "HEAD drift"
+	};
+	if (snapshotHash(await snapshotDirty(repo)) !== checkpoint.fingerprint) return {
+		resumable: false,
+		reason: "working tree fingerprint drift"
+	};
+	if (JSON.stringify([...manifest.ownership ?? []].sort()) !== JSON.stringify([...checkpoint.ownership].sort())) return {
+		resumable: false,
+		reason: "ownership checkpoint drift"
+	};
+	if (checkpoint.phase === "PREFLIGHT") return {
+		resumable: true,
+		reason: "checkpoint matches",
+		resumeFrom: "PREFLIGHT",
+		completedTaskIds: []
+	};
+	if (checkpoint.phase === "WORKERS" && checkpoint.safeBoundary) return {
+		resumable: true,
+		reason: "safe worker boundary matches",
+		resumeFrom: "WORKERS",
+		completedTaskIds: checkpoint.completedTaskIds ?? []
+	};
+	if (checkpoint.phase === "VALIDATING" || checkpoint.phase === "REVIEWING") return {
+		resumable: true,
+		reason: "final tree checkpoint matches",
+		resumeFrom: "VALIDATING",
+		completedTaskIds: checkpoint.completedTaskIds ?? []
+	};
+	return {
+		resumable: false,
+		reason: `phase ${checkpoint.phase} cannot be resumed without guessing mutation state`
+	};
+}
+function interruptManifest(manifest) {
+	if (!manifest.terminal) {
+		manifest.phase = "INTERRUPTED";
+		manifest.terminal = false;
+		manifest.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+	}
+	return manifest;
+}
+//#endregion
+//#region src/git/worktrees.ts
+function safeSegment(value) {
+	if (/^[A-Za-z0-9._-]{1,120}$/.test(value)) return value;
+	return createHash("sha256").update(value).digest("hex");
+}
+/** Engine lease ids may append -worktrees/-validation-* to the run UUID. All
+* physical leases still live under worktrees/<base-run-id>/ so terminal cleanup
+* owns one exact directory tree. */
+function worktreeRunKey(runId) {
+	return safeSegment(/^([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})(?:-|$)/i.exec(runId)?.[1] ?? runId);
+}
+async function createWorktree(repo, runId, taskId, head, root = stateRoot()) {
+	const runKey = worktreeRunKey(runId);
+	const path = confined(root, "worktrees", runKey, safeSegment(`${runId}--${taskId}`));
+	await mkdir(join(path, ".."), { recursive: true });
+	await git(repo, [
+		"worktree",
+		"add",
+		"--detach",
+		path,
+		head
+	]);
+	return {
+		path,
+		runId: runKey,
+		taskId,
+		baseHead: head
+	};
+}
+async function removeOwnedWorktree(repo, lease, force = false) {
+	await git(repo, [
+		"worktree",
+		"remove",
+		...force ? ["--force"] : [],
+		lease.path
+	]);
+	await rm(lease.path, {
+		recursive: true,
+		force: true
+	}).catch(() => {});
+}
+async function cleanupRunWorktrees(repo, runId, root = stateRoot()) {
+	const runRoot = resolve(confined(root, "worktrees", worktreeRunKey(runId)));
+	const listed = (await git(repo, [
+		"worktree",
+		"list",
+		"--porcelain",
+		"-z"
+	])).stdout.toString("utf8").split("\0");
+	for (const rec of listed) {
+		const line = rec.split("\n").find((x) => x.startsWith("worktree "));
+		if (!line) continue;
+		const path = resolve(line.slice(9));
+		if (path !== runRoot && !path.startsWith(runRoot + sep)) continue;
+		await git(repo, [
+			"worktree",
+			"remove",
+			"--force",
+			path
+		]).catch(() => {});
+		await rm(path, {
+			recursive: true,
+			force: true
+		}).catch(() => {});
+	}
+	await rm(runRoot, {
+		recursive: true,
+		force: true
+	}).catch(() => {});
+}
+//#endregion
+//#region src/orchestration/service.ts
+var OrchestrationService = class {
+	store;
+	runner;
+	#active = /* @__PURE__ */ new Map();
+	#activeRun = /* @__PURE__ */ new Map();
+	#pending = /* @__PURE__ */ new Map();
+	#controllers = /* @__PURE__ */ new Map();
+	#views = /* @__PURE__ */ new Map();
+	#agents = /* @__PURE__ */ new Map();
+	constructor(store, runner) {
+		this.store = store;
+		this.runner = runner;
+	}
+	approve(launch) {
+		if (this.#pending.has(launch.sessionId) || this.#active.has(launch.sessionId)) return false;
+		const runId = randomUUID();
+		const now = (/* @__PURE__ */ new Date()).toISOString();
+		const view = {
+			runId,
+			sessionId: launch.sessionId,
+			phase: "APPROVED_PENDING",
+			status: "APPROVED_PENDING",
+			tasksTotal: launch.artifact.tasks.length,
+			tasksDone: 0,
+			activeTaskIds: [],
+			reviewRound: 0,
+			startedAt: now,
+			updatedAt: now
+		};
+		this.#views.set(runId, view);
+		this.#agents.set(launch.sessionId, launch.agent);
+		this.append(launch.agent.session, "planx/run-approved", {
+			runId,
+			sessionId: launch.sessionId,
+			planHash: launch.planHash,
+			tasksTotal: launch.artifact.tasks.length,
+			at: now
+		});
+		const persisted = this.persistApproval(launch, runId, now);
+		this.#pending.set(launch.sessionId, {
+			runId,
+			launch,
+			persisted,
+			cancelled: false
+		});
+		if (launch.agent.status === "idle") queueMicrotask(() => void this.onParentIdle(launch.sessionId));
+		return runId;
+	}
+	shouldFence(sessionId) {
+		return this.#pending.has(sessionId);
+	}
+	activeRun(sessionId) {
+		return this.#pending.get(sessionId)?.runId ?? this.#activeRun.get(sessionId);
+	}
+	list(sessionId) {
+		return [...this.#views.values()].filter((view) => !sessionId || view.sessionId === sessionId).sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+	}
+	async detail(runId) {
+		const view = this.#views.get(runId);
+		if (!view) return void 0;
+		const dir = this.store.runDir(view.sessionId, runId);
+		const [completion, telemetry, worktrees, checkpoint] = await Promise.all([
+			readJson(join(dir, "completion.json")).catch(() => void 0),
+			readJson(join(dir, "telemetry.json")).catch(() => void 0),
+			readJson(join(dir, "worktrees.json")).catch(() => void 0),
+			readJson(join(dir, "recovery.json")).catch(() => void 0)
+		]);
+		const latestReview = await this.latestReview(dir, view.reviewRound);
+		return {
+			...view,
+			...completion,
+			usage: completion?.usage ?? telemetry,
+			review: latestReview?.verdict ?? completion?.review,
+			worktrees: worktrees?.worktrees ?? [],
+			recovery: checkpoint ? {
+				phase: checkpoint.phase,
+				safeBoundary: checkpoint.safeBoundary,
+				completedTaskIds: checkpoint.completedTaskIds
+			} : void 0
+		};
+	}
+	recordEvent(kind, data) {
+		const runId = String(data.runId ?? "");
+		const view = this.#views.get(runId);
+		if (!view) return;
+		const now = (/* @__PURE__ */ new Date()).toISOString();
+		const session = this.#agents.get(view.sessionId)?.session;
+		if (kind === "phase") {
+			view.phase = String(data.phase);
+			view.status = view.phase;
+			view.reviewRound = Number(data.reviewRound ?? view.reviewRound);
+			if (data.message) view.message = String(data.message);
+			this.append(session, "planx/run-phase", {
+				runId,
+				phase: view.phase,
+				message: data.message,
+				reviewRound: view.reviewRound,
+				at: now
+			});
+		} else if (kind === "task-start") {
+			if (!view.activeTaskIds.includes(data.taskId)) view.activeTaskIds.push(data.taskId);
+			this.append(session, "planx/task-start", {
+				runId,
+				taskId: String(data.taskId),
+				at: now
+			});
+		} else if (kind === "task-end") {
+			view.activeTaskIds = view.activeTaskIds.filter((id) => id !== data.taskId);
+			view.tasksDone = Math.min(view.tasksTotal, view.tasksDone + 1);
+			this.append(session, "planx/task-end", {
+				runId,
+				taskId: String(data.taskId),
+				status: String(data.status ?? ""),
+				at: now
+			});
+		} else if (kind === "validation") this.append(session, "planx/validation", {
+			runId,
+			commandId: String(data.commandId),
+			status: String(data.status),
+			at: now
+		});
+		else if (kind === "review") {
+			view.reviewRound = Number(data.round ?? view.reviewRound);
+			this.append(session, "planx/review", {
+				runId,
+				round: view.reviewRound,
+				verdict: String(data.verdict),
+				at: now
+			});
+		}
+		view.updatedAt = now;
+	}
+	async cancel(runId, reason = "user requested stop") {
+		const view = this.#views.get(runId);
+		if (!view) return false;
+		const sessionId = view.sessionId;
+		const pending = this.#pending.get(sessionId);
+		if (pending?.runId === runId) {
+			pending.cancelled = true;
+			let persistError;
+			try {
+				await pending.persisted;
+			} catch (error) {
+				persistError = error;
+			}
+			const controller = this.#controllers.get(runId);
+			const active = this.#active.get(sessionId);
+			if (controller && active) {
+				if (!controller.signal.aborted) controller.abort(reason);
+				await active.catch(() => {});
+			} else await this.markCancelled(view, reason, persistError);
+			if (this.#pending.get(sessionId) === pending) this.#pending.delete(sessionId);
+			return true;
+		}
+		if (this.#activeRun.get(sessionId) !== runId) return false;
+		const active = this.#active.get(sessionId);
+		const controller = this.#controllers.get(runId);
+		if (!active || !controller) return false;
+		if (!controller.signal.aborted) controller.abort(reason);
+		await active.catch(() => {});
+		return true;
+	}
+	async cancelSession(sessionId, reason = "Plan Orchestrator disabled") {
+		const runId = this.activeRun(sessionId);
+		return runId ? this.cancel(runId, reason) : false;
+	}
+	async cancelAll(reason = "Plan Orchestrator disabled") {
+		const sessionIds = /* @__PURE__ */ new Set([...this.#pending.keys(), ...this.#activeRun.keys()]);
+		await Promise.allSettled([...sessionIds].map((sessionId) => this.cancelSession(sessionId, reason)));
+	}
+	async onParentIdle(sessionId) {
+		const pending = this.#pending.get(sessionId);
+		if (!pending || pending.cancelled || this.#active.has(sessionId)) return false;
+		try {
+			await pending.persisted;
+		} catch (error) {
+			if (this.#pending.get(sessionId) === pending) this.#pending.delete(sessionId);
+			this.failView(pending.runId, "FAILED", `approval persistence failed: ${error.message}`);
+			return false;
+		}
+		if (pending.cancelled || this.#pending.get(sessionId) !== pending) return false;
+		const started = await this.start(pending.launch, pending.runId);
+		if (pending.cancelled) {
+			if (this.#pending.get(sessionId) === pending) this.#pending.delete(sessionId);
+			return false;
+		}
+		if (this.#pending.get(sessionId) === pending) this.#pending.delete(sessionId);
+		return started;
+	}
+	async reconcileSession(agent) {
+		const sessionId = String(agent.session.id);
+		this.#agents.set(sessionId, agent);
+		for (const view of reducePlanxEvents(sessionId, agent.session.snapshotEvents?.() ?? [])) this.#views.set(view.runId, view);
+		for (const original of await this.store.listSessionManifests(sessionId)) {
+			if (original.terminal) continue;
+			const manifest = interruptManifest(original);
+			await this.store.writeManifest(manifest);
+			const now = (/* @__PURE__ */ new Date()).toISOString();
+			const view = this.#views.get(manifest.runId) ?? {
+				runId: manifest.runId,
+				sessionId,
+				phase: "INTERRUPTED",
+				status: "INTERRUPTED",
+				tasksTotal: 0,
+				tasksDone: manifest.completedTaskIds?.length ?? 0,
+				activeTaskIds: [],
+				reviewRound: 0,
+				startedAt: manifest.createdAt,
+				updatedAt: now
+			};
+			view.phase = "INTERRUPTED";
+			view.status = "INTERRUPTED";
+			view.updatedAt = now;
+			this.#views.set(manifest.runId, view);
+			this.append(agent.session, "planx/recovery", {
+				runId: manifest.runId,
+				status: "INTERRUPTED",
+				message: "Previous process ended before a terminal checkpoint.",
+				at: now
+			});
+		}
+		return this.list(sessionId);
+	}
+	async resume(runId) {
+		const view = this.#views.get(runId);
+		if (!view || view.phase !== "INTERRUPTED" || this.#active.has(view.sessionId) || this.#pending.has(view.sessionId)) return {
+			ok: false,
+			reason: "run is not resumable in current state"
+		};
+		const agent = this.#agents.get(view.sessionId);
+		if (!agent) return {
+			ok: false,
+			reason: "session agent unavailable"
+		};
+		const manifest = await this.store.readManifest(view.sessionId, runId);
+		const dir = this.store.runDir(view.sessionId, runId);
+		const checkpoint = await readJson(join(dir, "recovery.json")).catch(() => void 0);
+		if (!checkpoint) return {
+			ok: false,
+			reason: "recovery checkpoint missing"
+		};
+		const diagnosis = await diagnoseResume(await repoRoot(agent.session.header?.cwd ?? process.cwd()), manifest, checkpoint);
+		if (!diagnosis.resumable) return {
+			ok: false,
+			reason: diagnosis.reason
+		};
+		const artifact = await readJson(join(dir, "plan.json"));
+		const launch = {
+			sessionId: view.sessionId,
+			agent,
+			artifact,
+			planHash: manifest.planHash,
+			baselineHead: manifest.baselineHead,
+			resumeFrom: diagnosis.resumeFrom,
+			completedTaskIds: diagnosis.completedTaskIds,
+			externalIssue: manifest.externalIssue ? {
+				...manifest.externalIssue,
+				publishAfterPass: Boolean(manifest.externalIssue.publishAfterPass)
+			} : void 0
+		};
+		manifest.phase = diagnosis.resumeFrom;
+		manifest.terminal = false;
+		await this.store.writeManifest(manifest);
+		const now = (/* @__PURE__ */ new Date()).toISOString();
+		this.append(agent.session, "planx/recovery", {
+			runId,
+			status: "RESUMING",
+			message: `Safe resume from ${diagnosis.resumeFrom}`,
+			at: now
+		});
+		await this.start(launch, runId);
+		return {
+			ok: true,
+			resumeFrom: diagnosis.resumeFrom
+		};
+	}
+	async cleanup(runId) {
+		const view = this.#views.get(runId);
+		if (!view || this.#active.has(view.sessionId)) return {
+			ok: false,
+			reason: "active or unknown run"
+		};
+		const manifest = await this.store.readManifest(view.sessionId, runId).catch(() => void 0);
+		if (!manifest?.terminal) return {
+			ok: false,
+			reason: "only terminal runs may be cleaned"
+		};
+		if (manifest.repoRoot) await cleanupRunWorktrees(manifest.repoRoot, runId, this.store.root).catch(() => {});
+		await this.store.removeRun(view.sessionId, runId);
+		return { ok: true };
+	}
+	async start(launch, runId) {
+		if (this.#active.has(launch.sessionId)) return false;
+		const controller = new AbortController();
+		this.#controllers.set(runId, controller);
+		this.#activeRun.set(launch.sessionId, runId);
+		let task;
+		try {
+			task = launch.agent.runMaintenance(async (signal) => this.run(launch, runId, AbortSignal.any([signal, controller.signal])));
+		} catch (error) {
+			this.#controllers.delete(runId);
+			if (this.#activeRun.get(launch.sessionId) === runId) this.#activeRun.delete(launch.sessionId);
+			throw error;
+		}
+		task = task.finally(() => {
+			this.#active.delete(launch.sessionId);
+			this.#controllers.delete(runId);
+			if (this.#activeRun.get(launch.sessionId) === runId) this.#activeRun.delete(launch.sessionId);
+		});
+		this.#active.set(launch.sessionId, task);
+		task.catch(() => {});
+		return true;
+	}
+	async run(launch, runId, signal) {
+		const initial = await this.store.readManifest(launch.sessionId, runId);
+		initial.phase = launch.resumeFrom ?? "PREFLIGHT";
+		initial.terminal = false;
+		await this.store.writeManifest(initial);
+		this.recordEvent("phase", {
+			runId,
+			phase: initial.phase
+		});
+		let terminalPhase = "COMPLETE";
+		let terminalMessage;
+		let thrown;
+		try {
+			await this.runner(launch, runId, signal);
+		} catch (error) {
+			thrown = error;
+			terminalMessage = error.message;
+			terminalPhase = signal.aborted ? "CANCELLED" : /(drift|ownership|blocked|inconclusive|unsafe|conflict|escape|checkpoint|tampered|stale)/i.test(terminalMessage) ? "BLOCKED" : "FAILED";
+		}
+		const latest = await this.store.readManifest(launch.sessionId, runId);
+		latest.phase = terminalPhase;
+		latest.terminal = true;
+		await this.store.writeManifest(latest);
+		this.recordEvent("phase", {
+			runId,
+			phase: terminalPhase,
+			message: terminalMessage
+		});
+		this.append(launch.agent.session, "planx/run-terminal", {
+			runId,
+			phase: terminalPhase,
+			...terminalMessage ? { message: terminalMessage } : {},
+			at: (/* @__PURE__ */ new Date()).toISOString()
+		});
+		if (thrown !== void 0) throw thrown;
+	}
+	async persistApproval(launch, runId, now) {
+		const dir = this.store.runDir(launch.sessionId, runId);
+		const manifest = {
+			schemaVersion: 1,
+			runId,
+			sessionId: launch.sessionId,
+			planHash: launch.planHash,
+			phase: "APPROVED_PENDING",
+			terminal: false,
+			createdAt: now,
+			updatedAt: now,
+			baselineHead: launch.baselineHead,
+			ownership: [...new Set(launch.artifact.tasks.flatMap((task) => task.modify))].sort(),
+			completedTaskIds: [],
+			externalIssue: launch.externalIssue ? {
+				issueNumber: launch.externalIssue.issueNumber,
+				repository: launch.externalIssue.repository,
+				revision: launch.externalIssue.revision,
+				branch: launch.externalIssue.branch,
+				publishAfterPass: launch.externalIssue.publishAfterPass
+			} : void 0,
+			artifacts: {}
+		};
+		await this.store.writeManifest(manifest);
+		await atomicJson(join(dir, "plan.json"), launch.artifact);
+	}
+	async markCancelled(view, reason, persistError) {
+		view.phase = "CANCELLED";
+		view.status = "CANCELLED";
+		view.message = persistError ? `${reason}; approval persistence failed: ${persistError.message}` : reason;
+		view.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+		this.append(this.#agents.get(view.sessionId)?.session, "planx/run-terminal", {
+			runId: view.runId,
+			phase: "CANCELLED",
+			message: view.message,
+			at: view.updatedAt
+		});
+		const manifest = await this.store.readManifest(view.sessionId, view.runId).catch(() => void 0);
+		if (manifest) {
+			manifest.phase = "CANCELLED";
+			manifest.terminal = true;
+			await this.store.writeManifest(manifest);
+		}
+	}
+	append(session, type, data) {
+		if (!session || typeof session.append !== "function") throw new Error(`plan-orchestrator cannot persist ${type}: session append unavailable`);
+		session.append(type, data);
+	}
+	failView(runId, phase, message) {
+		const view = this.#views.get(runId);
+		if (!view) return;
+		view.phase = phase;
+		view.status = phase;
+		view.message = message;
+		view.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+		this.append(this.#agents.get(view.sessionId)?.session, "planx/run-terminal", {
+			runId,
+			phase,
+			message,
+			at: view.updatedAt
+		});
+	}
+	async latestReview(dir, round) {
+		for (let index = round; index >= 0; index--) {
+			const value = await readJson(join(dir, `review-${index}.json`)).catch(() => void 0);
+			if (value) return value;
+		}
+	}
+};
+//#endregion
+//#region src/orchestration/enabled-parent-fence.ts
+/**
+* Runtime-gated parent fence. Enabled OFF is a hard execution boundary: every
+* event re-checks settings, pending and active plugin-owned runs are cancelled,
+* then the native DSH flow is allowed through unchanged.
+*/
+function installEnabledParentFence(ctx, service, isEnabled) {
+	const cancelOwnedRun = async (agent) => {
+		const sessionId = String(agent?.session?.id ?? "");
+		if (!sessionId) return;
+		await service.cancelSession(sessionId, "Plan Orchestrator disabled");
+	};
+	const preStep = ctx.on("agent/pre-step", async ({ agent }, next) => {
+		if (!isEnabled(agent)) {
+			await cancelOwnedRun(agent);
+			return next();
+		}
+		const sessionId = String(agent.session.id);
+		if (!service.shouldFence(sessionId)) return next();
+		await next();
+		return { kind: "reject" };
+	}, { prepend: true });
+	const status = ctx.on("agent/status", ({ agent, status }) => {
+		if (!isEnabled(agent)) {
+			cancelOwnedRun(agent).catch((error) => {
+				ctx.logger?.warn?.("plan-orchestrator run cleanup after disable failed: %o", error);
+			});
+			return;
+		}
+		if (status === "idle") service.onParentIdle(String(agent.session.id)).catch((error) => {
+			ctx.logger?.error?.("plan-orchestrator maintenance launch failed: %o", error);
+		});
+	});
+	return () => {
+		preStep?.();
+		status?.();
+	};
+}
+//#endregion
+//#region src/git/patches.ts
+async function capturePatch(root, baseHead, taskId, paths) {
+	const files = [];
+	for (const path of [...new Set(paths)].sort()) {
+		const fp = await fingerprintPath(root, path);
+		if (fp.kind === "missing") files.push({
+			path,
+			kind: "delete"
+		});
+		else if (fp.kind === "symlink") files.push({
+			path,
+			kind: "symlink",
+			target: await readlink(join(root, path))
+		});
+		else {
+			const b = await readFile(join(root, path));
+			files.push({
+				path,
+				kind: "file",
+				contentBase64: b.toString("base64"),
+				sha256: createHash("sha256").update(b).digest("hex")
+			});
+		}
+	}
+	const raw = {
+		version: 1,
+		baseHead,
+		taskId,
+		files
+	};
+	return {
+		...raw,
+		sha256: createHash("sha256").update(JSON.stringify(raw)).digest("hex")
+	};
+}
+//#endregion
+//#region src/orchestration/integrator.ts
+function needsIntegrator(taskCount, hasWorktreePatch, crossTaskWiring, conflict) {
+	return !(taskCount === 1 && !hasWorktreePatch && !crossTaskWiring && !conflict);
+}
+function verifyPatch(patch) {
+	const { sha256, ...raw } = patch;
+	if (createHash("sha256").update(JSON.stringify(raw)).digest("hex") !== sha256) throw new Error(`patch artifact hash mismatch for ${patch.taskId}`);
+	for (const f of patch.files) if (f.kind === "file") {
+		const bytes = Buffer.from(f.contentBase64 ?? "", "base64");
+		if (createHash("sha256").update(bytes).digest("hex") !== f.sha256) throw new Error(`patch file hash mismatch: ${f.path}`);
+	}
+}
+function assertSymlinkTarget(root, path, target) {
+	if (!target) throw new Error(`empty symlink target: ${path}`);
+	const b = resolve(root), resolved = resolve(dirname(join(b, path)), target);
+	if (resolved !== b && !resolved.startsWith(b + sep)) throw new Error(`symlink target escapes repository: ${path} -> ${target}`);
+}
+async function applyPatchArtifact(root, patch, unionOwnership) {
+	verifyPatch(patch);
+	const paths = patch.files.map((f) => f.path);
+	assertOwnedPaths(paths, unionOwnership);
+	await assertRepoPathsConfined(root, paths);
+	for (const f of patch.files) {
+		const target = join(root, f.path);
+		if (f.kind === "delete") {
+			await rm(target, { force: true });
+			continue;
+		}
+		await mkdir(dirname(target), { recursive: true });
+		if (f.kind === "symlink") {
+			assertSymlinkTarget(root, f.path, f.target);
+			await rm(target, { force: true });
+			await symlink(f.target, target);
+			continue;
+		}
+		await writeFile(target, Buffer.from(f.contentBase64, "base64"));
+	}
+}
+function integratorPrompt(planJson, handoffs, patchLocators) {
+	return `Role: Integrator\nDo not redesign or expand scope. You may modify only union ownership. Account for every accepted Worker patch; missing/ambiguous artifacts are BLOCKED. Never commit/push/reset/clean.\n\nAuthoritative PlanArtifact:\n${planJson}\n\nBounded handoff:\n${handoffs.join("\n")}\n\nPatch locators:\n${patchLocators.join("\n")}`;
+}
+//#endregion
+//#region src/orchestration/scheduler.ts
+function buildWaves(plan, maxParallel = 3, mode = "auto", platform = process.platform) {
+	new Map(plan.tasks.map((t) => [t.id, t]));
+	const done = /* @__PURE__ */ new Set(), remaining = new Set(plan.tasks.map((t) => t.id)), waves = [];
+	while (remaining.size) {
+		const ready = plan.tasks.filter((t) => remaining.has(t.id) && t.dependsOn.every((d) => done.has(d)));
+		if (!ready.length) throw new Error("scheduler deadlock");
+		if (mode !== "serial" && maxParallel > 1) {
+			const candidates = ready.filter((t) => t.parallelSafe);
+			const selected = [];
+			for (const t of candidates) {
+				if (selected.length >= maxParallel) break;
+				if (selected.every((s) => disjointOwnership(s.modify, t.modify, platform))) selected.push(t);
+			}
+			if (selected.length >= 2) {
+				const ids = selected.map((t) => t.id);
+				waves.push({
+					mode: "parallel",
+					taskIds: ids
+				});
+				for (const id of ids) {
+					remaining.delete(id);
+					done.add(id);
+				}
+				continue;
+			}
+		}
+		const t = ready[0];
+		waves.push({
+			mode: "serial",
+			taskIds: [t.id]
+		});
+		remaining.delete(t.id);
+		done.add(t.id);
+	}
+	return waves;
+}
+function recheckWave(plan, wave, platform = process.platform) {
+	if (wave.mode === "serial") return true;
+	const tasks = wave.taskIds.map((id) => plan.tasks.find((t) => t.id === id));
+	return tasks.length >= 2 && tasks.every((t) => t.parallelSafe) && tasks.every((t, i) => tasks.slice(i + 1).every((o) => disjointOwnership(t.modify, o.modify, platform))) && tasks.every((t) => t.dependsOn.every((d) => !wave.taskIds.includes(d)));
+}
+//#endregion
+//#region src/orchestration/task-packet.ts
+function buildTaskPacket(plan, task, dependencyHandoff = []) {
+	return [
+		`Role: Worker`,
+		`Task ID: ${task.id}`,
+		`Objective: ${task.objective}`,
+		`Global Decision Locks:\n${plan.decisionLocks.map((x) => `- ${x}`).join("\n") || "- none"}`,
+		`Task Decision Locks:\n${task.decisionLocks.map((x) => `- ${x}`).join("\n") || "- none"}`,
+		`Prioritized read targets (start here; expand only for a concrete blocker):\n${task.read.map((x) => `- ${x}`).join("\n") || "- none"}`,
+		`Exact modify ownership (MUST NOT mutate outside):\n${task.modify.map((x) => `- ${x}`).join("\n")}`,
+		`Required changes:\n${task.requiredChanges.map((x) => `- ${x}`).join("\n")}`,
+		`Acceptance criteria:\n${task.acceptanceCriteria.map((x) => `- ${x}`).join("\n")}`,
+		`Validation requested:\n${task.validation.map((x) => `- ${x}`).join("\n") || "- host validation follows"}`,
+		`Dependency handoff:\n${dependencyHandoff.map((x) => `- ${x}`).join("\n") || "- none"}`,
+		`Context expansion: if you need files outside initial read targets, record a concrete blocker and expansion reason. Do not read the Planner conversation.`,
+		`Return only the configured structured completion contract.`
+	].join("\n\n");
+}
+//#endregion
+//#region src/contract/role-result.ts
+const ROLE_RESULT_SCHEMA = {
+	type: "object",
+	additionalProperties: false,
+	properties: {
+		taskId: {
+			type: "string",
+			maxLength: 200
+		},
+		status: {
+			type: "string",
+			enum: [
+				"COMPLETE",
+				"BLOCKED",
+				"FAILED"
+			]
+		},
+		changed: {
+			type: "array",
+			items: {
+				type: "string",
+				maxLength: 512
+			},
+			maxItems: 200
+		},
+		validation: {
+			type: "array",
+			items: {
+				type: "object",
+				additionalProperties: false,
+				properties: {
+					id: {
+						type: "string",
+						maxLength: 200
+					},
+					status: {
+						type: "string",
+						enum: [
+							"PASS",
+							"FAIL",
+							"INCONCLUSIVE"
+						]
+					},
+					detail: {
+						type: "string",
+						maxLength: 2e3
+					}
+				},
+				required: ["id", "status"]
+			},
+			maxItems: 30
+		},
+		remaining: {
+			type: "array",
+			items: {
+				type: "string",
+				maxLength: 1e3
+			},
+			maxItems: 30
+		},
+		contextExpansion: {
+			type: "array",
+			items: {
+				type: "string",
+				maxLength: 1e3
+			},
+			maxItems: 30
+		}
+	},
+	required: [
+		"taskId",
+		"status",
+		"changed",
+		"validation",
+		"remaining",
+		"contextExpansion"
+	]
+};
+const KEYS = /* @__PURE__ */ new Set([
+	"taskId",
+	"status",
+	"changed",
+	"validation",
+	"remaining",
+	"contextExpansion"
+]);
+const VKEYS = /* @__PURE__ */ new Set([
+	"id",
+	"status",
+	"detail"
+]);
+function boundedStrings(value, name, maxItems, maxChars) {
+	if (!Array.isArray(value) || value.length > maxItems) throw new Error(`${name} invalid`);
+	for (const item of value) if (typeof item !== "string" || item.length > maxChars) throw new Error(`${name} invalid`);
+	return value;
+}
+function validateRoleResult(value, taskId) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error("role result must be an object");
+	const x = value;
+	const unknown = Object.keys(x).filter((k) => !KEYS.has(k));
+	if (unknown.length) throw new Error(`role result unknown fields: ${unknown.join(", ")}`);
+	if (x.taskId !== taskId || typeof x.taskId !== "string" || x.taskId.length > 200) throw new Error("role taskId mismatch");
+	if (![
+		"COMPLETE",
+		"BLOCKED",
+		"FAILED"
+	].includes(String(x.status))) throw new Error("role status invalid");
+	boundedStrings(x.changed, "changed", 200, 512);
+	boundedStrings(x.remaining, "remaining", 30, 1e3);
+	boundedStrings(x.contextExpansion, "contextExpansion", 30, 1e3);
+	if (!Array.isArray(x.validation) || x.validation.length > 30) throw new Error("validation invalid");
+	for (const item of x.validation) {
+		if (!item || typeof item !== "object" || Array.isArray(item)) throw new Error("validation invalid");
+		const v = item;
+		if (Object.keys(v).some((k) => !VKEYS.has(k)) || typeof v.id !== "string" || v.id.length > 200 || ![
+			"PASS",
+			"FAIL",
+			"INCONCLUSIVE"
+		].includes(String(v.status)) || v.detail !== void 0 && (typeof v.detail !== "string" || v.detail.length > 2e3)) throw new Error("validation invalid");
+	}
+	const encoded = JSON.stringify(value);
+	if (Buffer.byteLength(encoded, "utf8") > 128 * 1024) throw new Error("role result exceeds 128KiB");
+	return value;
+}
+//#endregion
+//#region src/telemetry/usage.ts
+const num = (v) => Number.isFinite(v) ? Number(v) : void 0;
+function usageFromSession(ctx, role, session, route) {
+	try {
+		const state = ctx.sessionProjections?.stateOf?.(session, "tokenUsage");
+		const totals = state?.totals ?? state;
+		const uncached = num(totals?.uncachedInputTokens), read = num(totals?.cacheReadTokens), write = num(totals?.cacheWriteTokens), output = num(totals?.outputTokens);
+		let pressure;
+		try {
+			pressure = num(ctx.get?.("tokenMeter")?.measure?.(session)?.totalTokens);
+		} catch {}
+		if ([
+			uncached,
+			read,
+			write,
+			output
+		].every((v) => typeof v === "number")) return {
+			role,
+			uncachedInput: uncached,
+			cacheRead: read,
+			cacheWrite: write,
+			output,
+			input: uncached + read + write,
+			provider: route?.provider,
+			model: route?.model,
+			pressureTokens: pressure,
+			source: "dsh-token-projection"
+		};
+	} catch {}
+	return {
+		role,
+		provider: route?.provider,
+		model: route?.model,
+		source: "unavailable"
+	};
+}
+function usageInEvent(event) {
+	if (event?.type === "assistant/message" && event.data?.usage) return event.data.usage;
+	const stream = event?.data?.stream;
+	if (!Array.isArray(stream)) return void 0;
+	for (let i = stream.length - 1; i >= 0; i--) {
+		const u = stream[i]?.usage ?? stream[i]?.chunk?.usage;
+		if (u) return u;
+	}
+}
+function usageFromSdkEvents(role, events, route) {
+	let uncached = 0, read = 0, write = 0, output = 0, samples = 0;
+	const seen = /* @__PURE__ */ new Map();
+	for (const event of events) {
+		if (event?.type !== "assistant/message" && event?.type !== "assistant/attempt" && event?.type !== "llm/retry-started") continue;
+		if (event.type === "llm/retry-started") {
+			seen.delete(`${event.data?.turn}:${event.data?.step}`);
+			continue;
+		}
+		const u = usageInEvent(event);
+		if (!u) continue;
+		const key = `${event.data?.turn}:${event.data?.step}`, next = {
+			uncached: Number(u.inputTokens ?? 0),
+			read: Number(u.cacheReadTokens ?? 0),
+			write: Number(u.cacheWriteTokens ?? 0),
+			output: Number(u.outputTokens ?? 0)
+		}, prev = seen.get(key);
+		if (prev) {
+			uncached -= prev.uncached;
+			read -= prev.read;
+			write -= prev.write;
+			output -= prev.output;
+		} else samples++;
+		uncached += next.uncached;
+		read += next.read;
+		write += next.write;
+		output += next.output;
+		seen.set(key, next);
+	}
+	return samples ? {
+		role,
+		uncachedInput: uncached,
+		cacheRead: read,
+		cacheWrite: write,
+		output,
+		input: uncached + read + write,
+		turns: samples,
+		provider: route?.provider,
+		model: route?.model,
+		source: "sdk-events"
+	} : {
+		role,
+		provider: route?.provider,
+		model: route?.model,
+		source: "unavailable"
+	};
+}
+//#endregion
+//#region src/runtime-policy.ts
+let timeoutResolver = () => 9e5;
+function configureRoleTimeoutResolver(resolver) {
+	const previous = timeoutResolver;
+	timeoutResolver = resolver;
+	return () => {
+		if (timeoutResolver === resolver) timeoutResolver = previous;
+	};
+}
+function roleTimeoutMs(cwd) {
+	const value = timeoutResolver(cwd);
+	if (!Number.isSafeInteger(value) || value < 1e3 || value > 36e5) throw new Error("invalid Plan Orchestrator role timeout");
+	return value;
+}
+function withRoleTimeout(cwd, signal) {
+	return AbortSignal.any([signal, AbortSignal.timeout(roleTimeoutMs(cwd))]);
+}
+//#endregion
+//#region src/orchestration/ownership-guard.ts
+const FILE_MUTATORS = /^(?:write|write_file|edit|edit_file|delete|delete_file|move|move_file|rename|rename_file|mkdir|make_directory|apply_patch|patch)$/i;
+const PATH_KEYS = /* @__PURE__ */ new Set([
+	"path",
+	"file",
+	"filePath",
+	"file_path",
+	"target",
+	"destination",
+	"dest",
+	"to",
+	"source",
+	"src",
+	"from",
+	"newPath",
+	"new_path",
+	"oldPath",
+	"old_path"
+]);
+function patchPaths(text) {
+	const out = [];
+	for (const line of text.split(/\r?\n/)) {
+		let match = /^\*\*\* (?:Update|Delete|Add) File:\s+(.+?)\s*$/.exec(line);
+		if (!match) match = /^(?:\+\+\+|---)\s+(?:[ab]\/)?(.+?)\s*$/.exec(line);
+		const value = match?.[1];
+		if (value && value !== "/dev/null") out.push(value);
+	}
+	return out;
+}
+function mutationTargetCandidates(toolName, args) {
+	if (!FILE_MUTATORS.test(toolName)) return void 0;
+	if (!args || typeof args !== "object" || Array.isArray(args)) return [];
+	const record = args;
+	const found = [];
+	for (const [key, value] of Object.entries(record)) {
+		if (PATH_KEYS.has(key)) {
+			if (typeof value === "string") found.push(value);
+			else if (Array.isArray(value)) found.push(...value.filter((item) => typeof item === "string"));
+		}
+		if ((key === "patch" || key === "diff" || key === "input") && typeof value === "string") found.push(...patchPaths(value));
+	}
+	return [...new Set(found.filter(Boolean))];
+}
+function toolPathToRepoRelative(root, raw) {
+	if (raw.includes("\0")) throw new Error("tool target contains NUL");
+	const absolute = isAbsolute(raw) ? resolve(raw) : resolve(root, raw);
+	const rel = relative(resolve(root), absolute);
+	if (!rel || rel === ".") throw new Error(`tool target is not an exact file: ${raw}`);
+	if (rel === ".." || rel.startsWith(`..${sep}`) || isAbsolute(rel)) throw new Error(`tool target escapes repository: ${raw}`);
+	return normalizeOwnedPath(rel.split(sep).join("/"));
+}
+function ownershipGuardReason(root, allowed, toolName, args) {
+	const candidates = mutationTargetCandidates(toolName, args);
+	if (candidates === void 0) return void 0;
+	if (candidates.length === 0) return `Plan Orchestrator ownership guard cannot identify target path for mutating tool ${toolName}`;
+	const allowedSet = new Set(allowed.map((path) => schedulerPathIdentity(path)));
+	try {
+		for (const raw of candidates) {
+			const relativePath = toolPathToRepoRelative(root, raw);
+			if (!allowedSet.has(schedulerPathIdentity(relativePath))) return `Plan Orchestrator ownership violation: ${relativePath}`;
+		}
+	} catch (error) {
+		return `Plan Orchestrator ownership violation: ${error.message}`;
+	}
+}
+/**
+* Install a monotonic guard before the one-shot child is created. A local
+* one-shot child records its direct parent in SessionHeader.parentSession, so
+* the guard can protect even the first tool call without waiting for start()
+* to return the child handle.
+*/
+function installChildOwnershipGuard(ctx, parent, root, allowed) {
+	if (!ctx.tools?.guard) throw new Error("tools.guard unavailable for exact ownership enforcement");
+	const parentId = String(parent.session.id);
+	return ctx.tools.guard((exec) => {
+		const agent = exec.agent;
+		if (!agent || String(agent.session?.header?.parentSession ?? "") !== parentId || agent.session?.header?.origin !== "subagent") return void 0;
+		return ownershipGuardReason(root, allowed, String(exec.name ?? ""), exec.arguments);
+	});
+}
+//#endregion
+//#region src/orchestration/native-backend.ts
+const OWNERSHIP_SAFE_MUTATION_TOOLS = [
+	"read",
+	"glob",
+	"grep",
+	"lsp",
+	"web_search",
+	"web_fetch",
+	"write",
+	"write_file",
+	"edit",
+	"edit_file",
+	"delete",
+	"delete_file",
+	"move",
+	"move_file",
+	"rename",
+	"rename_file",
+	"apply_patch",
+	"patch"
+];
+var NativeSpawnBackend = class {
+	ctx;
+	constructor(ctx) {
+		this.ctx = ctx;
+	}
+	async run(req) {
+		const started = Date.now();
+		const release = req.ownership ? installChildOwnershipGuard(this.ctx, req.parent, req.ownership.root, req.ownership.paths) : () => {};
+		let run;
+		try {
+			const cwd = req.parent?.session?.header?.cwd;
+			const signal = req.ownership ? withRoleTimeout(cwd, req.signal) : req.signal;
+			const toolFilter = req.ownership ? { allow: OWNERSHIP_SAFE_MUTATION_TOOLS } : req.toolFilter;
+			run = await this.ctx.subagents.start("spawn", {
+				label: `${req.role}:${req.taskId}`,
+				prompt: [{
+					type: "text",
+					text: req.prompt
+				}],
+				parent: req.parent,
+				signal,
+				agentOptions: req.route,
+				outputSchema: ROLE_RESULT_SCHEMA,
+				maxDepth: 1,
+				toolFilter,
+				persona: req.persona
+			});
+			const result = await run.result;
+			if (result.stopReason !== "completed") throw new Error(`subagent ${req.taskId} stopped: ${result.stopReason}${result.diagnostic ? `: ${result.diagnostic}` : ""}`);
+			const valid = validateRoleResult(result.structured, req.taskId);
+			const usage = run.localAgent ? usageFromSession(this.ctx, req.role, run.localAgent, req.route) : {
+				role: req.role,
+				provider: req.route.provider,
+				model: req.route.model,
+				source: "unavailable"
+			};
+			usage.durationMs = Date.now() - started;
+			return {
+				...valid,
+				__usage: usage
+			};
+		} finally {
+			try {
+				if (run) await run.dispose();
+			} finally {
+				release();
+			}
+		}
+	}
+};
+//#endregion
+//#region src/orchestration/sdk-backend.ts
+function extractEnvelope(text) {
+	const value = text.trim();
+	if (!value.startsWith("{") || !value.endsWith("}")) throw new Error("SDK worker must return one strict JSON envelope");
+	const parsed = JSON.parse(value);
+	if (JSON.stringify(parsed).length > 128 * 1024) throw new Error("SDK worker JSON envelope exceeds 128KiB");
+	return parsed;
+}
+/**
+* Keep only process/runtime facts plus provider credentials likely required by
+* the selected route. This intentionally does not serialize or persist the env.
+*/
+function minimalSdkEnv(source = process.env) {
+	const exact = /* @__PURE__ */ new Set([
+		"PATH",
+		"Path",
+		"PATHEXT",
+		"SystemRoot",
+		"SYSTEMROOT",
+		"COMSPEC",
+		"HOME",
+		"USERPROFILE",
+		"APPDATA",
+		"LOCALAPPDATA",
+		"TEMP",
+		"TMP",
+		"TMPDIR",
+		"LANG",
+		"LC_ALL",
+		"NODE_OPTIONS",
+		"HTTPS_PROXY",
+		"HTTP_PROXY",
+		"NO_PROXY",
+		"SSL_CERT_FILE",
+		"SSL_CERT_DIR",
+		"DSH_HOME"
+	]);
+	const prefix = /^(DSH_|OPENAI_|DEEPSEEK_|ANTHROPIC_|GOOGLE_|GEMINI_|COMMANDCODE_|CODEX_|AZURE_)/i;
+	const env = {};
+	for (const [key, value] of Object.entries(source)) if (value !== void 0 && (exact.has(key) || prefix.test(key))) env[key] = value;
+	return env;
+}
+function packagedProfilePath(role) {
+	const here = dirname(fileURLToPath(import.meta.url));
+	return join(basename(here) === "lib" ? resolve(here, "..") : resolve(here, "../.."), "profiles", `${role}.cordis.yml`);
+}
+function sdkHarnessOptions(req) {
+	const patches = req.patches ?? [packagedProfilePath(req.role ?? "worker")];
+	return {
+		profile: req.profile,
+		patches,
+		cwd: req.cwd,
+		processCwd: req.cwd,
+		provider: req.route.provider,
+		model: req.route.model,
+		reasoningEffort: req.route.reasoningEffort,
+		maxTokens: req.route.maxTokens,
+		env: req.env ?? minimalSdkEnv()
+	};
+}
+var SdkWorkspaceBackend = class {
+	async run(req) {
+		const signal = withRoleTimeout(req.cwd, req.signal);
+		signal.throwIfAborted();
+		const { DeepSeekHarness } = await import("@deepseek-ai/dsh-sdk-client");
+		const harness = new DeepSeekHarness(sdkHarnessOptions(req));
+		const started = Date.now();
+		let abortClose;
+		const abortPromise = new Promise((_, reject) => {
+			const onAbort = () => {
+				harness.close().catch(() => {});
+				reject(new DOMException("SDK worker aborted", "AbortError"));
+			};
+			signal.addEventListener("abort", onAbort, { once: true });
+			abortClose = () => signal.removeEventListener("abort", onAbort);
+		});
+		try {
+			const result = await Promise.race([harness.run(req.prompt), abortPromise]);
+			const valid = validateRoleResult(extractEnvelope(result.finalResponse), req.taskId);
+			const usage = usageFromSdkEvents("worker", result.events, req.route);
+			usage.durationMs = Date.now() - started;
+			return {
+				...valid,
+				__usage: usage
+			};
+		} finally {
+			abortClose?.();
+			await harness.close().catch(() => {});
+		}
+	}
+};
+//#endregion
+//#region src/orchestration/role-router.ts
+function routeChoices(route, current) {
+	return [route.mode === "current" ? current : {
+		provider: route.provider,
+		model: route.model,
+		reasoningEffort: route.reasoningEffort,
+		maxTokens: route.maxTokens
+	}, ...route.fallbacks].filter((v, i, a) => v.provider && v.model && a.findIndex((x) => x.provider === v.provider && x.model === v.model && x.reasoningEffort === v.reasoningEffort) === i);
+}
+async function preflightRoute(llm, choice) {
+	if (typeof llm?.resolveCallConfig !== "function") throw new Error("llm.resolveCallConfig unavailable");
+	await llm.resolveCallConfig(choice);
+	return choice;
+}
+//#endregion
+//#region src/validation/runner.ts
+let configuredShell;
+/** Bind validation to the current DSH shell seam. There is deliberately no
+* child_process fallback: missing sandboxed shell execution is release-blocking. */
+function configureValidationShell(shell) {
+	const previous = configuredShell;
+	configuredShell = shell;
+	return () => {
+		if (configuredShell === shell) configuredShell = previous;
+	};
+}
+function safe(value) {
+	return value.replace(/[^A-Za-z0-9._-]/g, "_").slice(0, 160);
+}
+async function assertExistingPackageScript(cwd, command) {
+	const parsed = parseValidationCommand(command);
+	let pkg;
+	try {
+		pkg = JSON.parse(await readFile(join(cwd, "package.json"), "utf8"));
+	} catch (error) {
+		throw new Error(`validation requires readable package.json: ${error.message}`);
+	}
+	if (!pkg?.scripts || typeof pkg.scripts[parsed.script] !== "string" || !pkg.scripts[parsed.script].trim()) throw new Error(`validation package script does not exist: ${parsed.script}`);
+}
+async function runValidation(opts) {
+	const shell = opts.shell ?? configuredShell;
+	if (!shell?.resolve || !shell?.run) throw new Error("sandboxed DSH shell executor unavailable for host validation");
+	await assertExistingPackageScript(opts.cwd, opts.command);
+	const before = await snapshotDirty(opts.cwd);
+	const head = await fullHead(opts.cwd);
+	const start = (/* @__PURE__ */ new Date()).toISOString();
+	const sandboxPolicy = {
+		mode: "workspace-write",
+		workspaceRoot: opts.cwd,
+		...opts.sessionId ? { sessionId: opts.sessionId } : {}
+	};
+	const spec = shell.resolve({
+		command: opts.command,
+		workdir: opts.cwd,
+		timeoutMs: opts.timeoutMs,
+		stdoutMaxBytes: opts.capBytes,
+		sandboxPolicy
+	});
+	const result = await shell.run(spec);
+	const stdout = Buffer.from(String(result?.stdout?.text ?? ""), "utf8");
+	const stderr = Buffer.from(String(result?.stderr?.text ?? ""), "utf8");
+	const stdoutTruncated = Boolean(result?.stdout?.truncated);
+	const stderrTruncated = Boolean(result?.stderr?.truncated);
+	const timedOut = Boolean(result?.timedOut);
+	const aborted = Boolean(result?.aborted);
+	const exitCode = typeof result?.exitCode === "number" ? result.exitCode : null;
+	const sandbox = result?.sandbox;
+	const sandboxIncomplete = !sandbox || sandbox.runnerFailed === true || sandbox.enforcement !== "full";
+	const sandboxDenied = Boolean(sandbox?.denied);
+	const validationDir = join(opts.runDir, "validation");
+	await mkdir(validationDir, { recursive: true });
+	const prefix = `${safe(opts.phase)}-${safe(opts.runId)}-${safe(opts.commandId)}`;
+	const stdoutPath = join(validationDir, `${prefix}.stdout.log`);
+	const stderrPath = join(validationDir, `${prefix}.stderr.log`);
+	await Promise.all([writeFile(stdoutPath, stdout), writeFile(stderrPath, stderr)]);
+	const after = await snapshotDirty(opts.cwd);
+	const mutated = snapshotHash(before) !== snapshotHash(after);
+	const status = sandboxDenied || mutated ? "UNSAFE_MUTATION" : sandboxIncomplete || stdoutTruncated || stderrTruncated || timedOut || aborted ? "INCONCLUSIVE" : exitCode === 0 ? "PASS" : "FAIL";
+	return {
+		schemaVersion: 1,
+		runId: opts.runId,
+		phase: opts.phase,
+		commandId: opts.commandId,
+		command: opts.command,
+		start,
+		end: (/* @__PURE__ */ new Date()).toISOString(),
+		timeoutMs: opts.timeoutMs,
+		exitCode: timedOut || aborted ? null : exitCode,
+		status,
+		stdout: {
+			path: stdoutPath,
+			sha256: hashBytes(stdout),
+			bytes: stdout.length,
+			truncated: stdoutTruncated
+		},
+		stderr: {
+			path: stderrPath,
+			sha256: hashBytes(stderr),
+			bytes: stderr.length,
+			truncated: stderrTruncated
+		},
+		boundHead: head,
+		ownershipFingerprint: opts.ownershipFingerprint ?? snapshotHash(after),
+		complete: !sandboxIncomplete && !sandboxDenied && !timedOut && !aborted && !stdoutTruncated && !stderrTruncated
+	};
+}
+//#endregion
+//#region src/orchestration/reviewer.ts
+function parseReviewVerdict(text) {
+	const first = text.split(/\r?\n/).find((l) => l.trim())?.trim();
+	if ([...text.matchAll(/\[REVIEW:(PASS|FAIL)\]/g)].map((m) => m[1]).length !== 1 || !first || !/^\[REVIEW:(PASS|FAIL)\]$/.test(first)) return {
+		kind: "PROTOCOL_INVALID",
+		detail: "Reviewer must emit exactly one leading verdict marker."
+	};
+	return first === "[REVIEW:PASS]" ? {
+		kind: "PASS",
+		detail: text
+	} : {
+		kind: "FAIL",
+		detail: text
+	};
+}
+const REVIEW_CONTRACT = `You are an independent read-only Reviewer. Do not trust Worker/Integrator self-reports. Review the authoritative plan, actual current diff, owned-path state, trusted validation receipts, and only necessary fresh semantic evidence. Check requirement fidelity, Decision Locks, scope integrity, ownership, correctness, compatibility, regression, security/data risk, validation sufficiency, planned task completeness, unrequested changes, and the actual diff. First non-blank line must be exactly [REVIEW:PASS] or [REVIEW:FAIL]. Emit exactly one marker. On FAIL, identify only concrete Plan-required defects suitable for a targeted fix.`;
+//#endregion
+//#region src/telemetry/aggregate.ts
+function aggregateUsage(samples) {
+	const sum = (k) => {
+		const vals = samples.map((s) => s[k]).filter((v) => typeof v === "number");
+		return vals.length && vals.length === samples.length ? vals.reduce((a, b) => a + b, 0) : void 0;
+	};
+	return {
+		input: sum("input"),
+		uncachedInput: sum("uncachedInput"),
+		cacheRead: sum("cacheRead"),
+		cacheWrite: sum("cacheWrite"),
+		output: sum("output"),
+		turns: sum("turns"),
+		durationMs: sum("durationMs"),
+		costUsd: void 0,
+		samples
+	};
+}
+//#endregion
+//#region src/orchestration/engine.ts
+const unionOwnership = (plan) => [...new Set(plan.tasks.flatMap((task) => task.modify))].sort();
+const currentRoute = (agent) => ({
+	provider: agent.options?.provider,
+	model: agent.options?.model,
+	reasoningEffort: agent.options?.reasoningEffort,
+	maxTokens: agent.options?.maxTokens
+});
+async function resolvedChoices(ctx, settings, role, agent) {
+	const candidates = routeChoices(settings.roles[role], currentRoute(agent));
+	const good = [];
+	const failures = [];
+	for (const choice of candidates) try {
+		good.push(await preflightRoute(ctx.llm, choice));
+	} catch (error) {
+		failures.push(`${choice.provider}/${choice.model}: ${error.message}`);
+	}
+	if (good.length === 0) throw new Error(`no valid ${role} route${failures.length ? ` (${failures.join("; ")})` : ""}`);
+	return good;
+}
+function continuationPacket(base, error) {
+	return `${base}\n\nCONTINUATION AFTER PROVIDER/TRANSPORT FAILURE:\nThe previous attempt may have mutated the working tree. First inspect the actual current tree. Preserve valid existing changes, complete only remaining Plan-required work, and never reset/checkout/clean/stash or blindly replay the task. Previous failure: ${String(error?.code ?? error?.message ?? error)}`;
+}
+/**
+* Fresh fallbacks are allowed until mutation occurs. Once any run-owned mutation
+* is observed, exactly one continuation attempt on the next route is allowed.
+*/
+async function runMutationRole(root, allowed, routes, run) {
+	const logicalBaseline = await snapshotDirty(root);
+	let lastError;
+	for (let index = 0; index < routes.length; index++) try {
+		return await run(routes[index], false, lastError);
+	} catch (error) {
+		lastError = error;
+		if (!eligibleTransportFailure(error)) throw error;
+		const changed = deltaPaths(logicalBaseline, await snapshotDirty(root));
+		assertOwnedPaths(changed, allowed);
+		if (changed.length > 0) {
+			if (index + 1 >= routes.length) throw error;
+			return run(routes[index + 1], true, error);
+		}
+		if (index + 1 >= routes.length) throw error;
+	}
+	throw lastError;
+}
+async function updateCheckpoint(store, launch, runId, root, head, ownership, phase, options = {}) {
+	const snapshot = await snapshotDirty(root);
+	const checkpoint = {
+		schemaVersion: 1,
+		head,
+		ownership: [...ownership].sort(),
+		changedPaths: Object.keys(snapshot.paths).sort(),
+		fingerprint: snapshotHash(snapshot),
+		phase,
+		role: options.role,
+		completedTaskIds: options.completedTaskIds ?? [],
+		safeBoundary: options.safeBoundary ?? false,
+		at: (/* @__PURE__ */ new Date()).toISOString()
+	};
+	await atomicJson(join(store.runDir(launch.sessionId, runId), "recovery.json"), checkpoint);
+	const manifest = await store.readManifest(launch.sessionId, runId);
+	manifest.phase = phase;
+	manifest.repoRoot = root;
+	manifest.baselineHead = head;
+	manifest.ownership = [...ownership].sort();
+	manifest.completedTaskIds = checkpoint.completedTaskIds;
+	await store.writeManifest(manifest);
+	return checkpoint;
+}
+async function writeWorktreeManifest(runDir, records) {
+	await atomicJson(join(runDir, "worktrees.json"), {
+		schemaVersion: 1,
+		worktrees: records
+	});
+}
+function dirtyOwnershipConflict(runBaseline, tasks) {
+	const dirty = new Set(Object.keys(runBaseline.paths));
+	return tasks.some((task) => task.modify.some((path) => dirty.has(path)));
+}
+async function boundedTextDiff(root, paths, preExisting, capBytes = 256 * 1024) {
+	const cleanPaths = paths.filter((path) => !preExisting.includes(path));
+	const dirtyPaths = paths.filter((path) => preExisting.includes(path));
+	let text = "";
+	if (cleanPaths.length > 0) {
+		const raw = decodeUtf8Strict((await git(root, [
+			"diff",
+			"--no-ext-diff",
+			"--unified=3",
+			"HEAD",
+			"--",
+			...cleanPaths
+		], { maxBuffer: capBytes * 2 })).stdout);
+		text += raw.length > capBytes ? `${raw.slice(0, capBytes)}\n[diff truncated by host]\n` : raw;
+	}
+	if (dirtyPaths.length > 0) text += `\nPre-existing dirty paths changed during this run; HEAD diff is not a clean attribution for these paths. Inspect current contents and the host fingerprints instead:\n${dirtyPaths.map((path) => `- ${path}`).join("\n")}\n`;
+	return text || "(no textual diff; binary/new/deleted paths may still be present)";
+}
+function reviewerPrompt(plan, changed, preExisting, receipts, actualDiff) {
+	return `${REVIEW_CONTRACT}\n\nAuthoritative PlanArtifact:\n${JSON.stringify(plan, null, 2)}\n\nRun-owned changed paths:\n${changed.map((path) => `- ${path}`).join("\n") || "- none"}\n\nPre-existing dirty paths (not attributable to this run unless their fingerprint changed after the run baseline):\n${preExisting.map((path) => `- ${path}`).join("\n") || "- none"}\n\nHost-observed actual diff/evidence:\n${actualDiff}\n\nTrusted validation receipt index:\n${JSON.stringify(receipts, null, 2)}\n\nUse read-only tools only when additional current-file evidence is necessary.`;
+}
+async function nativeReviewer(ctx, parent, prompt, routes, signal, label) {
+	let last;
+	for (let index = 0; index < routes.length; index++) {
+		const route = routes[index];
+		const started = Date.now();
+		try {
+			const run = await ctx.subagents.start("spawn", {
+				label: `${label}-${index}`,
+				prompt: [{
+					type: "text",
+					text: prompt
+				}],
+				parent,
+				signal,
+				agentOptions: route,
+				maxDepth: 1,
+				toolFilter: { allow: [
+					"read",
+					"glob",
+					"grep",
+					"lsp",
+					"web_search",
+					"web_fetch"
+				] },
+				persona: "Independent Reviewer. Strictly read-only. Review host evidence and current files; never mutate repository or external state."
+			});
+			try {
+				const result = await run.result;
+				if (result.stopReason !== "completed") {
+					const error = /* @__PURE__ */ new Error(`${label} stopped: ${result.stopReason}${result.diagnostic ? `: ${result.diagnostic}` : ""}`);
+					error.code = result.stopReason;
+					throw error;
+				}
+				const text = result.output.filter((block) => block.type === "text").map((block) => block.text).join("\n");
+				const usage = run.localAgent ? usageFromSession(ctx, "reviewer", run.localAgent, route) : {
+					role: "reviewer",
+					provider: route.provider,
+					model: route.model,
+					source: "unavailable"
+				};
+				usage.durationMs = Date.now() - started;
+				return {
+					text,
+					usage
+				};
+			} finally {
+				await run.dispose();
+			}
+		} catch (error) {
+			last = error;
+			if (!eligibleTransportFailure(error) || index === routes.length - 1) throw error;
+		}
+	}
+	throw last;
+}
+async function validateIsolated(root, head, leaseId, runDir, runId, changed, plan, settings, store, phase, emit) {
+	if (plan.validationCommands.length === 0) return [];
+	const fingerprint = await ownedFingerprint(root, changed);
+	const patch = await capturePatch(root, head, "__validation__", changed);
+	const lease = await createWorktree(root, leaseId, "__validation__", head, store.root);
+	let clean = false;
+	try {
+		await applyPatchArtifact(lease.path, patch, changed);
+		const receipts = [];
+		for (const command of plan.validationCommands) {
+			const receipt = await runValidation({
+				cwd: lease.path,
+				runDir,
+				runId,
+				phase,
+				commandId: command.id,
+				command: command.command,
+				timeoutMs: command.timeoutMs,
+				capBytes: Math.min(settings.review.outputCapBytes, 16 * 1024 * 1024),
+				ownershipFingerprint: fingerprint
+			});
+			receipts.push(receipt);
+			await atomicJson(join(runDir, "validation", `${phase.toLowerCase()}-${command.id}.receipt.json`), receipt);
+			emit?.("validation", {
+				runId,
+				commandId: command.id,
+				status: receipt.status
+			});
+			if (receipt.status !== "PASS") throw new Error(`${phase.toLowerCase()} validation ${command.id}: ${receipt.status}`);
+		}
+		await assertTrustedReceipts(receipts, head, fingerprint);
+		clean = true;
+		return receipts;
+	} finally {
+		if (clean || !settings.execution.keepFailedWorktrees) await removeOwnedWorktree(root, lease, true).catch(() => {});
+	}
+}
+async function executeSerialTask(deps, launch, task, plan, root, workerRoutes, signal, handoffs, usage) {
+	deps.emit?.("task-start", {
+		runId: launch.__runId,
+		taskId: task.id
+	});
+	const before = await snapshotDirty(root);
+	const basePacket = buildTaskPacket(plan, task, handoffs);
+	const backend = new NativeSpawnBackend(deps.ctx);
+	const result = await runMutationRole(root, task.modify, workerRoutes, (route, continuation, error) => backend.run({
+		parent: launch.agent,
+		role: "worker",
+		taskId: task.id,
+		prompt: continuation ? continuationPacket(basePacket, error) : basePacket,
+		route,
+		signal,
+		persona: "Fresh Worker. Implement only the assigned Plan task and exact modify ownership. Never commit, push, reset, clean, stash, or discard user work.",
+		ownership: {
+			root,
+			paths: task.modify
+		}
+	}));
+	if (result.status !== "COMPLETE") throw new Error(`worker ${task.id}: ${result.status}`);
+	if (result.__usage) usage.push(result.__usage);
+	const changed = deltaPaths(before, await snapshotDirty(root));
+	assertOwnedPaths(changed, task.modify);
+	return {
+		task,
+		result,
+		changed
+	};
+}
+async function executeWorktreeTask(deps, launch, runId, leaseRunId, runDir, root, head, task, plan, workerRoutes, signal, handoffs, usage, records, seedPatch) {
+	deps.emit?.("task-start", {
+		runId,
+		taskId: task.id
+	});
+	const lease = await createWorktree(root, leaseRunId, task.id, head, deps.store.root);
+	const record = {
+		taskId: task.id,
+		path: lease.path,
+		baseHead: head,
+		status: "ACTIVE"
+	};
+	records.push(record);
+	await writeWorktreeManifest(runDir, records);
+	let accepted = false;
+	try {
+		if (seedPatch) await applyPatchArtifact(lease.path, seedPatch, seedPatch.files.map((file) => file.path));
+		const before = await snapshotDirty(lease.path);
+		const basePacket = `${buildTaskPacket(plan, task, handoffs)}\n\nIMPORTANT: return exactly one JSON object matching the completion contract, with no markdown fence or prose.`;
+		const backend = new SdkWorkspaceBackend();
+		const result = await runMutationRole(lease.path, task.modify, workerRoutes, (route, continuation, error) => backend.run({
+			cwd: lease.path,
+			profile: deps.settings(root).execution.sdkProfile,
+			taskId: task.id,
+			prompt: continuation ? continuationPacket(basePacket, error) : basePacket,
+			route,
+			signal
+		}));
+		if (result.status !== "COMPLETE") throw new Error(`worker ${task.id}: ${result.status}`);
+		if (result.__usage) usage.push(result.__usage);
+		const after = await snapshotDirty(lease.path);
+		const changed = deltaPaths(before, after);
+		assertOwnedPaths(changed, task.modify);
+		const patch = await capturePatch(lease.path, head, task.id, changed);
+		await atomicJson(join(runDir, "patches", `${task.id}.json`), patch);
+		record.status = "CAPTURED";
+		record.fingerprint = snapshotHash(after);
+		record.patchSha256 = patch.sha256;
+		await writeWorktreeManifest(runDir, records);
+		accepted = true;
+		return {
+			task,
+			result,
+			changed,
+			patch
+		};
+	} catch (error) {
+		record.status = "FAILED";
+		await writeWorktreeManifest(runDir, records).catch(() => {});
+		throw error;
+	} finally {
+		if (accepted || !deps.settings(root).execution.keepFailedWorktrees) {
+			await removeOwnedWorktree(root, lease, true).catch(() => {});
+			record.status = "CLEANED";
+			await writeWorktreeManifest(runDir, records).catch(() => {});
+		}
+	}
+}
+function normalizeWaveForResume(wave, completed) {
+	const taskIds = wave.taskIds.filter((id) => !completed.has(id));
+	if (taskIds.length === 0) return void 0;
+	return taskIds.length === 1 ? {
+		mode: "serial",
+		taskIds
+	} : {
+		...wave,
+		taskIds
+	};
+}
+function createOrchestratorRunner(deps) {
+	return async (launch, runId, signal) => {
+		launch.__runId = runId;
+		const { ctx, store } = deps;
+		const plan = launch.artifact;
+		const root = await repoRoot(launch.agent.session.header?.cwd ?? process.cwd());
+		const settings = deps.settings(root);
+		const head = await fullHead(root);
+		if (launch.baselineHead && launch.baselineHead !== head) throw new Error(`approved baseline HEAD drift: ${launch.baselineHead} -> ${head}`);
+		const allOwned = unionOwnership(plan);
+		await assertRepoPathsConfined(root, allOwned);
+		const runDir = store.runDir(launch.sessionId, runId);
+		await mkdir(join(runDir, "patches"), { recursive: true });
+		const baselinePath = join(runDir, "baseline.json");
+		let runBaseline;
+		if (launch.resumeFrom) runBaseline = await readJson(baselinePath);
+		else {
+			runBaseline = await snapshotDirty(root);
+			await atomicJson(baselinePath, runBaseline);
+			await updateCheckpoint(store, launch, runId, root, head, allOwned, "PREFLIGHT", {
+				safeBoundary: true,
+				completedTaskIds: []
+			});
+		}
+		const workerRoutes = await resolvedChoices(ctx, settings, "worker", launch.agent);
+		const handoffPath = join(runDir, "handoffs.json");
+		const handoffs = launch.resumeFrom ? await readJson(handoffPath).catch(() => []) : [];
+		const usage = [];
+		const worktreeRecords = await readJson(join(runDir, "worktrees.json")).then((v) => v.worktrees).catch(() => []);
+		const completed = new Set(launch.completedTaskIds ?? []);
+		let hadWorktree = worktreeRecords.some((record) => record.status === "CAPTURED" || record.status === "CLEANED");
+		if (launch.resumeFrom !== "VALIDATING") {
+			deps.emit?.("phase", {
+				runId,
+				sessionId: launch.sessionId,
+				phase: "WORKERS"
+			});
+			const configuredWaves = buildWaves(plan, settings.execution.maxParallelWorkers, settings.execution.parallelMode);
+			const leaseRunId = `${runId}-worktrees`;
+			for (const configured of configuredWaves) {
+				const wave = normalizeWaveForResume(configured, completed);
+				if (!wave) continue;
+				signal.throwIfAborted();
+				const waveTasks = wave.taskIds.map((id) => plan.tasks.find((task) => task.id === id));
+				if (!(wave.mode === "parallel" && recheckWave(plan, wave) && !dirtyOwnershipConflict(runBaseline, waveTasks))) {
+					for (const task of waveTasks) {
+						const outcome = await executeSerialTask(deps, launch, task, plan, root, workerRoutes, signal, handoffs, usage);
+						handoffs.push(`${task.id}: host-observed=${outcome.changed.join(",") || "(none)"} status=${outcome.result.status}`);
+						completed.add(task.id);
+						deps.emit?.("task-end", {
+							runId,
+							taskId: task.id,
+							status: outcome.result.status
+						});
+						await atomicJson(handoffPath, handoffs);
+						await updateCheckpoint(store, launch, runId, root, head, allOwned, "WORKERS", {
+							completedTaskIds: [...completed],
+							safeBoundary: true
+						});
+					}
+					continue;
+				}
+				hadWorktree = true;
+				const mainBefore = await snapshotDirty(root);
+				if (mainBefore.head !== head) throw new Error("HEAD drift before parallel wave");
+				const priorRunDelta = deltaPaths(runBaseline, mainBefore);
+				assertOwnedPaths(priorRunDelta, allOwned);
+				const seedPatch = priorRunDelta.length > 0 ? await capturePatch(root, head, "__wave_seed__", priorRunDelta) : void 0;
+				const outcomes = await Promise.all(waveTasks.map((task) => executeWorktreeTask(deps, launch, runId, leaseRunId, runDir, root, head, task, plan, workerRoutes, signal, handoffs, usage, worktreeRecords, seedPatch)));
+				if (snapshotHash(await snapshotDirty(root)) !== snapshotHash(mainBefore)) throw new Error("working tree drift while parallel workers were isolated; refusing to apply patches");
+				if (await fullHead(root) !== head) throw new Error("HEAD drift before applying parallel worker patches");
+				for (const outcome of outcomes) {
+					if (!outcome.patch) throw new Error(`missing patch artifact for ${outcome.task.id}`);
+					await applyPatchArtifact(root, outcome.patch, allOwned);
+					handoffs.push(`${outcome.task.id}: host-observed=${outcome.changed.join(",") || "(none)"} status=${outcome.result.status}`);
+					completed.add(outcome.task.id);
+					deps.emit?.("task-end", {
+						runId,
+						taskId: outcome.task.id,
+						status: outcome.result.status
+					});
+				}
+				await atomicJson(handoffPath, handoffs);
+				await updateCheckpoint(store, launch, runId, root, head, allOwned, "WORKERS", {
+					completedTaskIds: [...completed],
+					safeBoundary: true
+				});
+			}
+			if (completed.size !== plan.tasks.length) throw new Error(`worker stage incomplete: ${completed.size}/${plan.tasks.length}`);
+			if (needsIntegrator(plan.tasks.length, hadWorktree, plan.tasks.length > 1, false)) {
+				deps.emit?.("phase", {
+					runId,
+					sessionId: launch.sessionId,
+					phase: "INTEGRATING"
+				});
+				const integratorBefore = await snapshotDirty(root);
+				const routes = await resolvedChoices(ctx, settings, "integrator", launch.agent);
+				const backend = new NativeSpawnBackend(ctx);
+				const basePrompt = integratorPrompt(JSON.stringify(plan), handoffs, hadWorktree ? [join(runDir, "patches")] : []);
+				const result = await runMutationRole(root, allOwned, routes, (route, continuation, error) => backend.run({
+					parent: launch.agent,
+					role: "integrator",
+					taskId: "__integrator__",
+					prompt: continuation ? continuationPacket(basePrompt, error) : basePrompt,
+					route,
+					signal,
+					persona: "Integrator. Reconcile only Plan-required cross-task wiring. Never redesign, commit, push, reset, clean, stash, or touch files outside union ownership.",
+					ownership: {
+						root,
+						paths: allOwned
+					}
+				}));
+				if (result.status !== "COMPLETE") throw new Error(`integrator: ${result.status}`);
+				if (result.__usage) usage.push(result.__usage);
+				assertOwnedPaths(deltaPaths(integratorBefore, await snapshotDirty(root)), allOwned);
+			}
+			const afterMutation = await snapshotDirty(root);
+			assertOwnedPaths(deltaPaths(runBaseline, afterMutation), allOwned);
+			await updateCheckpoint(store, launch, runId, root, head, allOwned, "VALIDATING", {
+				completedTaskIds: [...completed],
+				safeBoundary: true
+			});
+		}
+		let finalSnapshot = await snapshotDirty(root);
+		let runDelta = deltaPaths(runBaseline, finalSnapshot);
+		assertOwnedPaths(runDelta, allOwned);
+		deps.emit?.("phase", {
+			runId,
+			sessionId: launch.sessionId,
+			phase: "VALIDATING"
+		});
+		let receipts = await validateIsolated(root, head, `${runId}-validation-${Date.now()}`, runDir, runId, runDelta, plan, settings, store, "VALIDATING", deps.emit);
+		await updateCheckpoint(store, launch, runId, root, head, allOwned, "REVIEWING", {
+			completedTaskIds: [...completed],
+			safeBoundary: true
+		});
+		deps.emit?.("phase", {
+			runId,
+			sessionId: launch.sessionId,
+			phase: "REVIEWING"
+		});
+		const reviewRoutes = await resolvedChoices(ctx, settings, "reviewer", launch.agent);
+		const preExisting = Object.keys(runBaseline.paths).sort();
+		let fixRound = 0;
+		while (true) {
+			finalSnapshot = await snapshotDirty(root);
+			runDelta = deltaPaths(runBaseline, finalSnapshot);
+			assertOwnedPaths(runDelta, allOwned);
+			const fingerprint = await ownedFingerprint(root, runDelta);
+			await assertTrustedReceipts(receipts, head, fingerprint);
+			const actualDiff = await boundedTextDiff(root, runDelta, preExisting);
+			const prompt = reviewerPrompt(plan, runDelta, preExisting, receiptIndex(receipts), actualDiff);
+			let reviewerText = "";
+			let verdict = {
+				kind: "PROTOCOL_INVALID",
+				detail: ""
+			};
+			for (let protocolAttempt = 0; protocolAttempt <= settings.review.protocolRetry; protocolAttempt++) {
+				const reviewed = await nativeReviewer(ctx, launch.agent, prompt, reviewRoutes, signal, `review-${fixRound}-${protocolAttempt}`);
+				reviewerText = reviewed.text;
+				usage.push(reviewed.usage);
+				verdict = parseReviewVerdict(reviewerText);
+				if (verdict.kind !== "PROTOCOL_INVALID") break;
+			}
+			if (verdict.kind === "PROTOCOL_INVALID") throw new Error("Reviewer protocol invalid after retry");
+			deps.emit?.("review", {
+				runId,
+				round: fixRound,
+				verdict: verdict.kind
+			});
+			await atomicJson(join(runDir, `review-${fixRound}.json`), {
+				verdict,
+				reviewerText
+			});
+			if (verdict.kind === "PASS") break;
+			if (fixRound >= settings.review.maxReviewRounds) throw new Error("Reviewer failed after maxReviewRounds");
+			fixRound += 1;
+			deps.emit?.("phase", {
+				runId,
+				sessionId: launch.sessionId,
+				phase: "FIXING",
+				reviewRound: fixRound
+			});
+			const fixBefore = await snapshotDirty(root);
+			const backend = new NativeSpawnBackend(ctx);
+			const basePrompt = `Targeted fix only. Reviewer findings:\n${verdict.detail}\n\nAuthoritative PlanArtifact:\n${JSON.stringify(plan)}\n\nYou may modify only these paths:\n${allOwned.join("\n")}\nDo not redesign, expand scope, commit, push, reset, clean, stash, or discard user work.`;
+			const result = await runMutationRole(root, allOwned, workerRoutes, (route, continuation, error) => backend.run({
+				parent: launch.agent,
+				role: "worker",
+				taskId: `__fix_${fixRound}__`,
+				prompt: continuation ? continuationPacket(basePrompt, error) : basePrompt,
+				route,
+				signal,
+				persona: "Targeted fix Worker. Fix only Reviewer-identified Plan-required defects.",
+				ownership: {
+					root,
+					paths: allOwned
+				}
+			}));
+			if (result.status !== "COMPLETE") throw new Error(`targeted fix: ${result.status}`);
+			if (result.__usage) usage.push(result.__usage);
+			assertOwnedPaths(deltaPaths(fixBefore, await snapshotDirty(root)), allOwned);
+			finalSnapshot = await snapshotDirty(root);
+			runDelta = deltaPaths(runBaseline, finalSnapshot);
+			assertOwnedPaths(runDelta, allOwned);
+			deps.emit?.("phase", {
+				runId,
+				sessionId: launch.sessionId,
+				phase: "VALIDATING",
+				reviewRound: fixRound
+			});
+			receipts = await validateIsolated(root, head, `${runId}-fix-${fixRound}-${Date.now()}`, runDir, runId, runDelta, plan, settings, store, "FIXING", deps.emit);
+			await updateCheckpoint(store, launch, runId, root, head, allOwned, "REVIEWING", {
+				completedTaskIds: [...completed],
+				safeBoundary: true
+			});
+		}
+		finalSnapshot = await snapshotDirty(root);
+		const finalDelta = deltaPaths(runBaseline, finalSnapshot);
+		assertOwnedPaths(finalDelta, allOwned);
+		const finalFingerprint = await ownedFingerprint(root, finalDelta);
+		await assertTrustedReceipts(receipts, head, finalFingerprint);
+		const usageSummary = aggregateUsage(usage);
+		await atomicJson(join(runDir, "telemetry.json"), usageSummary);
+		if (launch.externalIssue?.publishAfterPass) {
+			const { publishExternalRun } = await import("./publication-D352itYY.js");
+			await publishExternalRun({
+				cwd: root,
+				runDir,
+				meta: launch.externalIssue,
+				ownedPaths: finalDelta,
+				expectedHead: head,
+				expectedOwnershipFingerprint: finalFingerprint,
+				receipts
+			});
+		}
+		deps.emit?.("phase", {
+			runId,
+			sessionId: launch.sessionId,
+			phase: "COMPLETE"
+		});
+		await atomicJson(join(runDir, "completion.json"), {
+			runId,
+			planHash: launch.planHash,
+			review: "PASS",
+			changedPaths: finalDelta,
+			ownershipFingerprint: finalFingerprint,
+			receipts: receiptIndex(receipts),
+			usage: usageSummary,
+			completedAt: (/* @__PURE__ */ new Date()).toISOString()
+		});
+		try {
+			launch.agent.inject(createUserMessage({
+				content: [{
+					type: "text",
+					text: `Plan Orchestrator completed run ${runId}. Reviewer: PASS. Changed paths: ${finalDelta.join(", ") || "(none)"}. Validation: ${receipts.map((receipt) => `${receipt.commandId}=${receipt.status}`).join(", ") || "no host commands"}.`
+				}],
+				source: {
+					kind: "plugin",
+					plugin: "plan-orchestrator"
+				}
+			}));
+		} catch {}
+	};
+}
+//#endregion
+//#region src/orchestration/projection.ts
+const phaseSchema = z.enum([
+	"IDLE",
+	"PLANNING",
+	"PLAN_VALIDATED",
+	"APPROVED_PENDING",
+	"PREFLIGHT",
+	"WORKERS",
+	"INTEGRATING",
+	"VALIDATING",
+	"REVIEWING",
+	"FIXING",
+	"COMPLETE",
+	"BLOCKED",
+	"FAILED",
+	"INTERRUPTED",
+	"CANCELLED"
+]);
+const runSchema = z.object({
+	runId: z.string().min(1).max(200),
+	sessionId: z.string().min(1).max(300),
+	phase: phaseSchema,
+	status: z.string().max(100),
+	tasksTotal: z.number().int().nonnegative(),
+	tasksDone: z.number().int().nonnegative(),
+	activeTaskIds: z.array(z.string().max(200)).max(64),
+	reviewRound: z.number().int().nonnegative(),
+	message: z.string().max(2e3).optional(),
+	startedAt: z.string().max(64),
+	updatedAt: z.string().max(64)
+}).strict();
+const stateSchema = z.object({ runs: z.array(runSchema).max(20) }).strict();
+function replaceRun(state, run) {
+	return { runs: [run, ...state.runs.filter((row) => row.runId !== run.runId)].sort((a, b) => b.updatedAt.localeCompare(a.updatedAt)).slice(0, 20) };
+}
+function find(state, runId) {
+	return state.runs.find((run) => run.runId === runId);
+}
+const planOrchestratorProjectionDefinition = {
+	key: "planOrchestrator",
+	stateVersion: 1,
+	stateSchema,
+	init: () => ({ runs: [] }),
+	apply: (state, event) => {
+		const d = event.data;
+		if (event.type === "planx/run-approved") return replaceRun(state, {
+			runId: d.runId,
+			sessionId: d.sessionId,
+			phase: "APPROVED_PENDING",
+			status: "APPROVED_PENDING",
+			tasksTotal: d.tasksTotal,
+			tasksDone: 0,
+			activeTaskIds: [],
+			reviewRound: 0,
+			startedAt: d.at,
+			updatedAt: d.at
+		});
+		if (typeof d?.runId !== "string") return state;
+		const current = find(state, d.runId);
+		if (!current) return state;
+		let next = {
+			...current,
+			activeTaskIds: [...current.activeTaskIds]
+		};
+		switch (event.type) {
+			case "planx/run-phase":
+				next.phase = d.phase;
+				next.status = d.phase;
+				if (typeof d.reviewRound === "number") next.reviewRound = d.reviewRound;
+				if (typeof d.message === "string") next.message = d.message;
+				break;
+			case "planx/task-start":
+				if (!next.activeTaskIds.includes(d.taskId)) next.activeTaskIds.push(d.taskId);
+				break;
+			case "planx/task-end":
+				next.activeTaskIds = next.activeTaskIds.filter((id) => id !== d.taskId);
+				next.tasksDone = Math.min(next.tasksTotal, next.tasksDone + 1);
+				break;
+			case "planx/review":
+				next.reviewRound = d.round;
+				break;
+			case "planx/recovery":
+				next.status = d.status;
+				if (typeof d.message === "string") next.message = d.message;
+				break;
+			case "planx/run-terminal":
+				next.phase = d.phase;
+				next.status = d.phase;
+				next.activeTaskIds = [];
+				if (typeof d.message === "string") next.message = d.message;
+				break;
+			default: return state;
+		}
+		next.updatedAt = d.at;
+		return replaceRun(state, next);
+	},
+	wire: {
+		viewSchema: stateSchema,
+		view: (state) => state
+	}
+};
+//#endregion
+//#region src/external/contract.ts
+function meta(value) {
+	const e = value?.externalPlan;
+	if (!e || e.version !== 1 || !Number.isSafeInteger(e.revision) || e.revision < 1 || typeof e.repository !== "string" || !/^[-A-Za-z0-9_.]+\/[-A-Za-z0-9_.]+$/.test(e.repository) || typeof e.baseCommit !== "string" || !/^[0-9a-f]{40}$/.test(e.baseCommit)) throw new Error("invalid externalPlan metadata");
+	return {
+		version: 1,
+		revision: e.revision,
+		repository: e.repository,
+		baseCommit: e.baseCommit
+	};
+}
+function validateExternalContract(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error("external contract object required");
+	const externalPlan = meta(value);
+	let planInput;
+	if (value.plan && typeof value.plan === "object") planInput = value.plan;
+	else {
+		const { externalPlan: _ignored, ...rest } = value;
+		planInput = rest;
+	}
+	return {
+		externalPlan,
+		plan: validatePlanArtifact(planInput, true)
+	};
+}
+function canonical(value) {
+	if (Array.isArray(value)) return `[${value.map(canonical).join(",")}]`;
+	if (value && typeof value === "object") return `{${Object.keys(value).sort().map((k) => `${JSON.stringify(k)}:${canonical(value[k])}`).join(",")}}`;
+	return JSON.stringify(value);
+}
+function selectTrustedRevision(contracts) {
+	if (!contracts.length) throw new Error("no valid external contract");
+	const max = Math.max(...contracts.map((c) => c.externalPlan.revision)), same = contracts.filter((c) => c.externalPlan.revision === max);
+	if (new Set(same.map((c) => canonical(c))).size !== 1) throw new Error(`conflicting contracts at revision ${max}`);
+	return same[0];
+}
+function extractExternalContracts(text) {
+	const out = [];
+	for (const m of text.matchAll(/```json\s*\n([\s\S]*?)\n```/gi)) try {
+		out.push(validateExternalContract(JSON.parse(m[1])));
+	} catch {}
+	return out;
+}
+function validateCompletionEvidence(value) {
+	const e = value?.externalCompletion;
+	if (!e || e.version !== 1 || !Number.isSafeInteger(e.revision) || e.revision < 1 || typeof e.repository !== "string" || !Number.isSafeInteger(e.issue) || e.issue < 1 || !Number.isSafeInteger(e.pr) || e.pr < 1 || typeof e.head !== "string" || !/^[0-9a-f]{40}$/.test(e.head)) throw new Error("invalid external completion evidence");
+	return { externalCompletion: {
+		version: 1,
+		revision: e.revision,
+		repository: e.repository,
+		issue: e.issue,
+		pr: e.pr,
+		head: e.head
+	} };
+}
+function extractCompletionEvidence(text) {
+	if (!text.includes("IMPLEMENTATION COMPLETE")) return [];
+	const out = [];
+	for (const m of text.matchAll(/```json\s*\n([\s\S]*?)\n```/gi)) try {
+		out.push(validateCompletionEvidence(JSON.parse(m[1])));
+	} catch {}
+	return out;
+}
+//#endregion
+//#region src/external/continuation.ts
+function completionIsCurrent(evidence, revision, remoteHead) {
+	return Boolean(evidence && evidence.revision === revision && evidence.head === remoteHead);
+}
+async function findCurrentCompletion(evidences, opts) {
+	const matching = evidences.map((x) => x.externalCompletion).filter((x) => x.revision === opts.revision && x.repository === opts.repository && x.issue === opts.issue).sort((a, b) => b.pr - a.pr);
+	for (const e of matching) {
+		const head = await opts.remoteHead(e.pr);
+		if (head && completionIsCurrent({
+			revision: e.revision,
+			head: e.head
+		}, opts.revision, head)) return e;
+	}
+}
+//#endregion
+//#region src/external/issue-command.ts
+function parseIssueInput(raw) {
+	const m = /^\s*(\d+)\s*$/.exec(raw);
+	if (!m) return void 0;
+	const n = Number(m[1]);
+	return Number.isSafeInteger(n) && n > 0 ? n : void 0;
+}
+const issueBranch = (n) => `issue-${n}-external-plan`;
+function hashPlan(plan) {
+	return createHash("sha256").update(JSON.stringify(plan)).digest("hex");
+}
+function installIssueCommand(ctx, deps) {
+	if (!ctx.commands?.register) throw new Error("commands service unavailable");
+	return ctx.commands.register({
+		name: "plan-issue",
+		description: "Execute a trusted external PlanArtifact from a GitHub Issue",
+		input: {
+			hint: "<issue-number>",
+			attachments: false
+		},
+		recordInput: false,
+		handler: async ({ agent, rawInput }) => {
+			try {
+				const issueNumber = parseIssueInput(rawInput);
+				if (!issueNumber) return {
+					kind: "error",
+					text: "Usage: /plan-issue <positive issue number>"
+				};
+				const cwd = agent.session.header?.cwd ?? process.cwd();
+				const settings = deps.settings(cwd);
+				if (!settings.enabled) return {
+					kind: "error",
+					text: "Plan Orchestrator is disabled in Settings → Plan Mode."
+				};
+				if (!settings.externalIssue.enabled) return {
+					kind: "error",
+					text: "External Issue Mode is disabled in Settings → Plan Mode."
+				};
+				const actual = await ghRepository(cwd);
+				const repository = String(actual?.nameWithOwner ?? "");
+				if (!repository) throw new Error("current GitHub repository identity unavailable");
+				const texts = await trustedIssueTexts(cwd, repository, await fetchIssue(cwd, issueNumber));
+				if (texts.length === 0) throw new Error("no issue body/comment from a repository writer, maintainer, or admin");
+				const selected = selectTrustedRevision(texts.flatMap(extractExternalContracts).filter((contract) => contract.externalPlan.repository === repository));
+				await ghPreflight(cwd, selected.externalPlan.repository);
+				const current = await findCurrentCompletion(texts.flatMap(extractCompletionEvidence), {
+					revision: selected.externalPlan.revision,
+					repository: selected.externalPlan.repository,
+					issue: issueNumber,
+					remoteHead: async (pr) => {
+						try {
+							const remote = await remotePr(cwd, pr);
+							return remote?.state === "OPEN" ? remote.headRefOid : void 0;
+						} catch {
+							return;
+						}
+					}
+				});
+				if (current) return {
+					kind: "success",
+					text: `Issue #${issueNumber} revision ${current.revision} is already complete at PR #${current.pr} (${current.head}).`
+				};
+				const branch = issueBranch(issueNumber);
+				await prepareIssueBranch(cwd, branch, selected.externalPlan.baseCommit);
+				const run = deps.orchestration.approve({
+					sessionId: String(agent.session.id),
+					agent,
+					artifact: selected.plan,
+					planHash: hashPlan(selected.plan),
+					baselineHead: selected.externalPlan.baseCommit,
+					externalIssue: {
+						issueNumber,
+						repository: selected.externalPlan.repository,
+						revision: selected.externalPlan.revision,
+						branch,
+						publishAfterPass: Boolean(settings.externalIssue.publishAfterPass)
+					}
+				});
+				if (!run) return {
+					kind: "error",
+					text: "Another Plan Orchestrator run is already active for this session."
+				};
+				return {
+					kind: "success",
+					text: `Accepted Issue #${issueNumber} external plan revision ${selected.externalPlan.revision} on ${branch}. Execution run ${run} will start automatically.${settings.externalIssue.publishAfterPass ? " PASS will publish/reuse a PR." : " Automatic PR publication is disabled."}`
+				};
+			} catch (e) {
+				return {
+					kind: "error",
+					text: `External Issue Mode blocked: ${e.message}`
+				};
+			}
+		}
+	});
+}
+//#endregion
+//#region src/index.ts
+const name = "plan-orchestrator";
+const inject = [
+	"settings",
+	"tools",
+	"llm",
+	"sessions",
+	"subagents",
+	"systemPrompt",
+	"sandboxPolicy",
+	"sessionProjections",
+	"shell"
+];
+const execFileP = promisify(execFile);
+const require = createRequire(import.meta.url);
+function packageVersion(id) {
+	try {
+		return require(`${id}/package.json`).version;
+	} catch {
+		return;
+	}
+}
+async function commandAvailable(command, args) {
+	try {
+		await execFileP(command, args, {
+			windowsHide: true,
+			timeout: 5e3
+		});
+		return true;
+	} catch {
+		return false;
+	}
+}
+function hasService(ctx, name) {
+	try {
+		return ctx.get?.(name) !== void 0;
+	} catch {
+		return false;
+	}
+}
+function apply(ctx) {
+	const c = ctx;
+	const settings = registerSettings(c);
+	const bridge = new NativePlanBridge();
+	const readOnly = new PlannerReadOnlyGuard();
+	const store = new RunStore();
+	c.sessionProjections.register(planOrchestratorProjectionDefinition);
+	let orchestration;
+	orchestration = new OrchestrationService(store, createOrchestratorRunner({
+		ctx: c,
+		settings: (cwd) => settings.effective(cwd),
+		store,
+		emit: (kind, data) => orchestration?.recordEvent(kind, data)
+	}));
+	const isPlanActive = (agent) => {
+		try {
+			return Boolean(c.sessionProjections.stateOf(agent.session, "plan")?.active);
+		} catch {
+			return false;
+		}
+	};
+	const isEnabled = (agent) => Boolean(agent && settings.effective(agent.session?.header?.cwd).enabled);
+	const firstPolicySeen = /* @__PURE__ */ new WeakSet();
+	c.effect(() => configureValidationShell(c.shell), "plan-orchestrator: sandbox validation runtime");
+	c.effect(() => configureRoleTimeoutResolver((cwd) => settings.effective(cwd).execution.roleTimeoutMs), "plan-orchestrator: role timeout runtime");
+	c.systemPrompt.section({
+		name: "plan-orchestrator:policy",
+		order: (c.systemPrompt.getSectionOrder?.("PLAN_POLICY") ?? 500) + 1,
+		text: ({ agent }) => {
+			if (!agent) return "";
+			const effective = settings.effective(agent.session.header?.cwd);
+			const session = agent.session;
+			if (!effective.enabled) {
+				firstPolicySeen.delete(session);
+				return "";
+			}
+			const active = isPlanActive(agent);
+			const first = !firstPolicySeen.has(session);
+			const text = plannerPolicyText(true, active, first, effective.planning);
+			if (text && first) firstPolicySeen.add(session);
+			return text;
+		}
+	});
+	c.effect(() => installExitPlanValidator(c, bridge, () => settings.get().execution.requireExplicitOwnership, isEnabled), "plan-orchestrator: validate native plan");
+	c.effect(() => readOnly.install(c, isEnabled), "plan-orchestrator: strict read-only tool guard");
+	c.effect(() => installPlannerRoute(c, (agent) => settings.effective(agent.session.header?.cwd).roles.planner, isPlanActive, isEnabled), "plan-orchestrator: planner route");
+	c.effect(() => installEnabledParentFence(c, orchestration, isEnabled), "plan-orchestrator: parent fence");
+	c.on("agent/pre-step", async ({ agent }, next) => {
+		const decision = await next();
+		const effective = settings.effective(agent.session.header?.cwd);
+		if (!effective.enabled) {
+			bridge.clearSession(String(agent.session.id));
+			readOnly.deactivate(agent.session, c.sandboxPolicy);
+			return decision;
+		}
+		if (decision.kind !== "reject" && effective.planning.strictReadOnly && isPlanActive(agent)) readOnly.activate(agent.session, c.sandboxPolicy);
+		else if (!isPlanActive(agent)) readOnly.deactivate(agent.session, c.sandboxPolicy);
+		return decision;
+	}, { prepend: true });
+	c.on("tools/result", (exec, result) => {
+		const staged = consumeApprovedPlanResult(bridge, exec, result, isEnabled);
+		if (!staged) return;
+		const sessionId = String(exec.agent?.session?.id ?? "");
+		orchestration.approve({
+			sessionId,
+			agent: exec.agent,
+			artifact: staged.artifact,
+			planHash: staged.hash,
+			baselineHead: staged.baselineHead
+		});
+	});
+	c.on("session/event", (session, event) => {
+		if (event.type !== "plan/mode") return;
+		firstPolicySeen.delete(session);
+		if (!settings.effective(session.header?.cwd).enabled) {
+			bridge.clearSession(String(session.id));
+			readOnly.deactivate(session, c.sandboxPolicy);
+			return;
+		}
+		if (!event.data.active) {
+			bridge.clearSession(String(session.id));
+			readOnly.deactivate(session, c.sandboxPolicy);
+		}
+	});
+	c.on("agent/session-start", ({ agent }) => {
+		if (!isEnabled(agent)) return;
+		orchestration.reconcileSession(agent).catch((error) => c.logger?.warn?.("plan-orchestrator recovery reconcile failed: %o", error));
+	});
+	c.inject(["commands"], (scope) => scope.effect(() => installIssueCommand(scope, {
+		settings: (cwd) => settings.effective(cwd),
+		orchestration
+	}), "plan-orchestrator: external issue command"));
+	c.inject(["connection"], (scope) => scope.effect(() => {
+		let disposed = false;
+		let disposeTransport;
+		import("./rpc-server-CGs2ndXP.js").then(({ registerRpc }) => {
+			if (disposed) return;
+			disposeTransport = registerRpc(scope.connection, {
+				ctx: scope,
+				isEnabled: () => settings.get().enabled,
+				canResume: () => settings.get().recovery.allowSafeResume,
+				runList: ({ sessionId }) => orchestration.list(sessionId),
+				runDetail: ({ runId }) => orchestration.detail(runId),
+				runCancel: ({ runId }) => orchestration.cancel(runId),
+				runResume: ({ runId }) => orchestration.resume(runId),
+				runCleanup: ({ runId }) => orchestration.cleanup(runId),
+				externalPreflight: async (body) => {
+					const cwd = typeof body.cwd === "string" ? await repoRoot(body.cwd) : void 0;
+					if (!cwd || typeof body.repository !== "string") throw new Error("cwd and repository required");
+					return ghPreflight(cwd, body.repository);
+				},
+				diagnostics: async (body) => {
+					const cwd = typeof body.cwd === "string" ? body.cwd : void 0;
+					let gitAvailable = await commandAvailable("git", ["--version"]);
+					let repo = false;
+					if (gitAvailable && cwd) try {
+						await repoRoot(cwd);
+						repo = true;
+					} catch {}
+					return {
+						pluginVersion: "1.0.0",
+						dshVersion: packageVersion("@deepseek-ai/dsh-plan-mode"),
+						compatibility: {
+							supported: ["0.1.5-rc.1"],
+							preview: ["0.1.5-rc.2"]
+						},
+						nativePlanMode: hasService(scope, "planMode"),
+						sdkAvailable: packageVersion("@deepseek-ai/dsh-sdk-client") !== void 0,
+						gitAvailable,
+						gitRepository: repo,
+						lspAvailable: hasService(scope, "lsp"),
+						ghAvailable: await commandAvailable("gh", ["--version"]),
+						settingsWritable: settings.writable(),
+						storage: store.root,
+						readOnlyDegraded: typeof body.sessionId === "string" ? readOnly.degraded(body.sessionId) : void 0
+					};
+				}
+			});
+		}).catch((error) => scope.logger?.error?.("plan-orchestrator RPC registration failed: %o", error));
+		return () => {
+			disposed = true;
+			disposeTransport?.();
+		};
+	}, "plan-orchestrator: rpc"));
+	settings.watch((value) => {
+		if (!value.enabled) {
+			orchestration.cancelAll("Plan Orchestrator disabled in settings").catch((error) => c.logger?.warn?.("plan-orchestrator disable cancellation failed: %o", error));
+			return;
+		}
+		for (const role of Object.values(value.roles)) if (role.mode === "fixed") validateFixedRoute(c.llm, role).catch((error) => c.logger?.warn?.("plan-orchestrator fixed route unavailable: %s", error.message));
+	});
+}
+//#endregion
+export { apply, inject, name };