@klarkxy/dsh-fusion 0.1.0

package/lib/index.js

@@ -0,0 +1,1670 @@
+import { FUSION_PLUGIN, FUSION_PURPOSE, FUSION_RPC_CHANNEL, FUSION_TOOLS, emptyFusionState, isWorking } from "./contracts.js";
+import { registerHostRpc } from "@klarkxy/dsh-ai-services";
+import { createHash, randomUUID } from "node:crypto";
+import { defineDomain, domainTable } from "@deepseek-ai/dsh-storage-domain";
+import { z } from "zod";
+import { foldSubagentDescriptor } from "@deepseek-ai/dsh-subagent";
+import { defineTool } from "@deepseek-ai/dsh-tools";
+//#region src/validation.ts
+var FusionError = class extends Error {
+	code;
+	constructor(code, message) {
+		super(message);
+		this.name = "FusionError";
+		this.code = code;
+	}
+};
+function requireFusion(condition, code, message) {
+	if (!condition) throw new FusionError(code, message);
+}
+function text(value, label, max, empty = false) {
+	requireFusion(typeof value === "string" && value.length <= max && (empty || value.trim().length > 0), "INVALID_INPUT", `${label} must be ${empty ? "0" : "1"}–${max} characters.`);
+	return value;
+}
+function integer(value, label) {
+	requireFusion(Number.isSafeInteger(value) && Number(value) >= 1, "INVALID_INPUT", `${label} must be a positive integer.`);
+	return value;
+}
+function object(value) {
+	requireFusion(value !== null && typeof value === "object" && !Array.isArray(value), "INVALID_INPUT", "Expected an object.");
+	return value;
+}
+function stringList(value, label, limit = 32) {
+	requireFusion(Array.isArray(value) && value.length <= limit, "INVALID_INPUT", `${label} must have at most ${limit} items.`);
+	return value.map((item) => text(item, label, 2e3));
+}
+function brief(value) {
+	const row = object(value);
+	return {
+		title: text(row.title, "title", 120),
+		goal: text(row.goal, "goal", 8e3),
+		context: text(row.context ?? "", "context", 48e3, true),
+		constraints: stringList(row.constraints ?? [], "constraints"),
+		acceptance: stringList(row.acceptance ?? [], "acceptance")
+	};
+}
+function route(value) {
+	const row = object(value);
+	return {
+		provider: text(row.provider, "provider", 300),
+		model: text(row.model, "model", 300),
+		...row.reasoningEffort === void 0 ? {} : { reasoningEffort: text(row.reasoningEffort, "reasoningEffort", 100) }
+	};
+}
+function json(value, depth = 0) {
+	requireFusion(depth <= 12, "INVALID_INPUT", "Target is nested too deeply.");
+	if (value === null || typeof value === "boolean" || typeof value === "string") return;
+	if (typeof value === "number") {
+		requireFusion(Number.isFinite(value), "INVALID_INPUT", "Non-finite target value.");
+		return;
+	}
+	if (Array.isArray(value)) {
+		requireFusion(value.length <= 128, "INVALID_INPUT", "Target array too large.");
+		value.forEach((item) => json(item, depth + 1));
+		return;
+	}
+	const row = object(value);
+	requireFusion(Object.keys(row).length <= 128, "INVALID_INPUT", "Target object too large.");
+	for (const [key, item] of Object.entries(row)) {
+		requireFusion(![
+			"__proto__",
+			"constructor",
+			"prototype"
+		].includes(key), "INVALID_INPUT", "Unsafe target key.");
+		json(item, depth + 1);
+	}
+}
+function target(value) {
+	if (value === void 0) return void 0;
+	const row = object(value);
+	const domain = text(row.domain, "target domain", 100);
+	const data = object(row.data);
+	json(data);
+	requireFusion(JSON.stringify(data).length <= 2e5, "INVALID_INPUT", "Target exceeds storage limit.");
+	return {
+		domain,
+		data: structuredClone(data)
+	};
+}
+function timestamp(value) {
+	requireFusion(typeof value === "number" && Number.isSafeInteger(value) && value >= 0, "INVALID_STATE", "Invalid record timestamp.");
+}
+/** Validate persisted control records before allowing any native work to resume. */
+function validateState(value) {
+	const row = object(value);
+	requireFusion(row.version === 1 && Number.isSafeInteger(row.revision) && Number(row.revision) >= 0, "INVALID_STATE", "Unsupported Fusion storage version.");
+	requireFusion(Array.isArray(row.pairs) && row.pairs.length <= 512, "INVALID_STATE", "Invalid Fusion pair table.");
+	const pairIds = /* @__PURE__ */ new Set(), leads = /* @__PURE__ */ new Set(), children = /* @__PURE__ */ new Set(), tasks = /* @__PURE__ */ new Set();
+	for (const value of row.pairs) {
+		const pair = object(value);
+		const pairId = text(pair.id, "pair id", 200);
+		requireFusion(!pairIds.has(pairId), "INVALID_STATE", "Duplicate pair identity.");
+		pairIds.add(pairId);
+		timestamp(pair.createdAt);
+		text(pair.project, "project identity", 8192);
+		const lead = text(pair.leadSessionId, "lead id", 200), child = text(pair.childSessionId, "child id", 200);
+		requireFusion(!leads.has(lead) && !children.has(child) && lead !== child, "INVALID_STATE", "Duplicate Fusion identity.");
+		leads.add(lead);
+		children.add(child);
+		requireFusion(pair.profile === "generic" || pair.profile === "writing", "INVALID_STATE", "Unknown Fusion profile.");
+		requireFusion(typeof pair.established === "boolean", "INVALID_STATE", "Missing admission state.");
+		route(pair.route);
+		requireFusion(Array.isArray(pair.tasks) && pair.tasks.length <= 128, "INVALID_STATE", "Invalid task table.");
+		for (const value of pair.tasks) {
+			const task = object(value), id = text(task.id, "task id", 200);
+			requireFusion(!tasks.has(id), "INVALID_STATE", "Duplicate task identity.");
+			tasks.add(id);
+			timestamp(task.createdAt);
+			timestamp(task.updatedAt);
+			if (task.error !== void 0) text(task.error, "task error", 16e3, true);
+			if (task.decision !== void 0) text(task.decision, "task decision", 16e3, true);
+			integer(task.revision, "task revision");
+			brief(task.brief);
+			target(task.target);
+			requireFusion([
+				"dispatching",
+				"working",
+				"decision",
+				"review",
+				"accepted",
+				"cancelled",
+				"failed",
+				"interrupted"
+			].includes(String(task.state)), "INVALID_STATE", "Unknown task state.");
+			requireFusion([
+				"pending",
+				"accepted",
+				"uncertain"
+			].includes(String(task.delivery)), "INVALID_STATE", "Unknown delivery state.");
+			text(task.dispatchId, "dispatch id", 200);
+			stringList(task.messageIds, "message ids", 64);
+			const reportIds = stringList(task.reportIds, "report ids", 64);
+			if (task.notifiedReportId !== void 0) requireFusion(reportIds.includes(text(task.notifiedReportId, "notified report id", 256)), "INVALID_STATE", "Notification references an unknown report.");
+			requireFusion(Array.isArray(task.candidates) && task.candidates.length <= 16 && Array.isArray(task.reviews) && task.reviews.length <= 32, "INVALID_STATE", "Invalid candidate history.");
+			const candidates = /* @__PURE__ */ new Map();
+			for (const [index, item] of task.candidates.entries()) {
+				const candidate = object(item);
+				timestamp(candidate.createdAt);
+				const candidateId = text(candidate.id, "candidate id", 200);
+				requireFusion(!candidates.has(candidateId), "INVALID_STATE", "Duplicate candidate identity.");
+				requireFusion(integer(candidate.revision, "candidate revision") === index + 1, "INVALID_STATE", "Invalid candidate order.");
+				requireFusion(integer(candidate.taskRevision, "candidate task revision") <= Number(task.revision), "INVALID_STATE", "Candidate belongs to a future task revision.");
+				const candidateText = text(candidate.text, "candidate", 2e5, true);
+				text(candidate.report, "report", 16e3, true);
+				requireFusion(typeof candidate.hash === "string" && /^[a-f0-9]{64}$/.test(candidate.hash), "INVALID_STATE", "Invalid candidate hash.");
+				requireFusion(createHash("sha256").update(candidateText, "utf8").digest("hex") === candidate.hash, "INVALID_STATE", "Candidate content does not match its stored hash.");
+				candidates.set(candidateId, candidate.hash);
+			}
+			if (task.cleanup !== void 0) requireFusion([
+				"pending",
+				"done",
+				"failed"
+			].includes(String(task.cleanup)), "INVALID_STATE", "Invalid cleanup state.");
+			if (task.adoption !== void 0) requireFusion([
+				"pending",
+				"applied",
+				"dismissed",
+				"conflict"
+			].includes(String(task.adoption)) && pair.profile === "writing" && task.target, "INVALID_STATE", "Invalid adoption state.");
+			if (task.application !== void 0) {
+				const application = object(task.application);
+				text(application.id, "application id", 200);
+				text(application.path, "application path", 8192);
+				text(application.beforeVersion, "application baseline", 8192, true);
+				const destination = target(task.target);
+				requireFusion(destination && (destination.data.path === void 0 || destination.data.path === application.path), "INVALID_STATE", "Application path differs from its captured target.");
+				const candidateId = text(application.candidateId, "application candidate", 200);
+				const latest = object(task.candidates.at(-1));
+				requireFusion(latest.id === candidateId && latest.taskRevision === task.revision && candidates.get(candidateId) === application.candidateHash, "INVALID_STATE", "Application references an unknown candidate.");
+				requireFusion(typeof application.afterHash === "string" && /^[a-f0-9]{64}$/.test(application.afterHash), "INVALID_STATE", "Invalid resulting file hash.");
+				requireFusion([
+					"pending",
+					"applied",
+					"conflict"
+				].includes(String(application.state)) && pair.profile === "writing" && task.target && task.state === "accepted", "INVALID_STATE", "Invalid application state.");
+				if (application.version !== void 0) text(application.version, "application receipt version", 8192);
+				if (application.state === "pending") requireFusion(task.adoption === "pending", "INVALID_STATE", "Pending intent requires pending adoption.");
+				if (application.state === "conflict") requireFusion(task.adoption === "conflict" || task.adoption === "dismissed", "INVALID_STATE", "Conflicting intent requires conflict or dismissal.");
+				if (application.state === "applied") requireFusion(task.adoption === "applied" && application.version, "INVALID_STATE", "Applied intent requires a receipt.");
+			}
+			for (const item of task.reviews) {
+				const review = object(item);
+				timestamp(review.createdAt);
+				const candidateId = text(review.candidateId, "review candidate", 200);
+				const hash = text(review.candidateHash, "review hash", 64);
+				requireFusion(candidates.get(candidateId) === hash, "INVALID_STATE", "Review references an unknown candidate revision.");
+				requireFusion([
+					"accept",
+					"revise",
+					"reject"
+				].includes(String(review.verdict)), "INVALID_STATE", "Invalid review verdict.");
+				text(review.feedback, "feedback", 16e3, true);
+			}
+			if (task.state === "accepted") {
+				const candidate = task.candidates.at(-1) && object(task.candidates.at(-1));
+				const review = task.reviews.at(-1) && object(task.reviews.at(-1));
+				requireFusion(candidate && candidate.taskRevision === task.revision && review?.verdict === "accept" && review.candidateId === candidate.id && review.candidateHash === candidate.hash, "INVALID_STATE", "Accepted task must reference the latest accepted candidate.");
+			}
+		}
+	}
+	requireFusion([...children].every((id) => !leads.has(id)), "INVALID_STATE", "Recursive Fusion identity.");
+	requireFusion(JSON.stringify(row).length <= 16e6, "CAPACITY", "Fusion history capacity reached. Existing records were preserved.");
+	return structuredClone(row);
+}
+//#endregion
+//#region src/storage.ts
+/** One atomic business record; Sessions remain the transcript authority. */
+const fusionStateSchema = z.unknown().transform((value, ctx) => {
+	try {
+		return validateState(value);
+	} catch (error) {
+		ctx.addIssue({
+			code: "custom",
+			message: error instanceof Error ? error.message : "Invalid Fusion state"
+		});
+		return z.NEVER;
+	}
+});
+const fusionDomain = defineDomain({
+	name: "dsh_fusion",
+	version: 1,
+	tables: { state: domainTable(fusionStateSchema) }
+});
+const FUSION_STATE_KEY = "state";
+function createFusionStore(table) {
+	return {
+		load: () => validateState(table.get("state") ?? emptyFusionState()),
+		save: (next) => table.put(FUSION_STATE_KEY, validateState(next))
+	};
+}
+//#endregion
+//#region src/presentation.ts
+/** Only a structured and matching source can suppress a cancelled child's late wakeup. */
+function isOwnedChildNotice(source, childId) {
+	if (!source || typeof source !== "object") return false;
+	const row = source;
+	return (row.kind === "subagent-settled" || row.kind === "agent-message") && row.senderSessionId === childId;
+}
+//#endregion
+//#region src/service.ts
+const contentHash = (value) => createHash("sha256").update(value, "utf8").digest("hex");
+const clone = (value) => structuredClone(value);
+const currentTask = (pair) => pair.tasks.at(-1);
+/** Business records only. The native continuation manager owns Agents and all message scheduling. */
+var FusionService = class {
+	state;
+	pending = Promise.resolve();
+	enabled = true;
+	generation = 0;
+	storageFailed = false;
+	controller = new AbortController();
+	dispatches = /* @__PURE__ */ new Map();
+	applications = /* @__PURE__ */ new Map();
+	notifications = /* @__PURE__ */ new Map();
+	inFlight = /* @__PURE__ */ new Set();
+	ready;
+	store;
+	inspectAdmission;
+	native;
+	now;
+	id;
+	constructor(input) {
+		this.inspectAdmission = input.inspectAdmission;
+		this.store = input.store;
+		this.native = input.native;
+		this.now = input.now ?? Date.now;
+		this.id = input.id ?? randomUUID;
+		this.state = validateState(this.store.load() ?? emptyFusionState());
+		this.ready = this.change((next) => {
+			for (const pair of next.pairs) for (const task of pair.tasks) if (isWorking(task.state)) {
+				task.state = "interrupted";
+				task.delivery = "uncertain";
+				task.updatedAt = this.now();
+				task.error = "进程已重启。请核对执行记录后明确恢复；未自动重发任务。";
+			}
+		}, true);
+	}
+	get active() {
+		return this.enabled && !this.storageFailed;
+	}
+	async initialized() {
+		await this.ready;
+	}
+	snapshot() {
+		return clone(this.state);
+	}
+	pairFor(sessionId) {
+		const pair = this.state.pairs.find((pair) => pair.leadSessionId === sessionId || pair.childSessionId === sessionId);
+		return pair && clone(pair);
+	}
+	role(sessionId) {
+		const pair = this.state.pairs.find((pair) => pair.leadSessionId === sessionId || pair.childSessionId === sessionId);
+		return pair && (pair.leadSessionId === sessionId ? "lead" : "sidekick");
+	}
+	async persist(next) {
+		next.revision++;
+		validateState(next);
+		try {
+			await this.store.save(clone(next));
+		} catch (error) {
+			this.storageFailed = true;
+			this.generation++;
+			this.controller.abort();
+			throw error;
+		}
+		this.state = clone(next);
+	}
+	change(fn, allowInactive = false) {
+		const result = this.pending.then(async () => {
+			requireFusion(allowInactive || this.enabled, "DISABLED", "Fusion is disabled.");
+			requireFusion(allowInactive || !this.storageFailed, "STORAGE_FAILED", "Fusion storage failed. Reload after repairing storage; no new work was admitted.");
+			const next = clone(this.state), value = await fn(next);
+			await this.persist(next);
+			return clone(value);
+		});
+		this.pending = result.then(() => void 0, () => void 0);
+		return result;
+	}
+	owned(next, actor, side) {
+		const pair = next.pairs.find((pair) => (side === "lead" ? pair.leadSessionId : pair.childSessionId) === actor.sessionId);
+		requireFusion(pair && pair.project === actor.project && (side !== "sidekick" || actor.parentSessionId === pair.leadSessionId), "UNAUTHORIZED", "This session does not own the Fusion task.");
+		if (side === "lead") requireFusion(!actor.parentSessionId, "UNAUTHORIZED", "A child cannot become a Fusion Lead.");
+		return pair;
+	}
+	task(pair, taskId, revision) {
+		const task = currentTask(pair);
+		requireFusion(task?.id === taskId && task.revision === revision, "STALE", "This task revision is no longer current.");
+		return task;
+	}
+	isCurrent(pairId, taskId, revision, generation) {
+		if (!this.enabled || this.storageFailed || generation !== this.generation) return false;
+		const pair = this.state.pairs.find((pair) => pair.id === pairId), task = pair && currentTask(pair);
+		return task?.id === taskId && task.revision === revision && isWorking(task.state);
+	}
+	track(operation) {
+		this.inFlight.add(operation);
+		operation.finally(() => this.inFlight.delete(operation)).catch(() => {});
+		return operation;
+	}
+	abortNotifications(taskId) {
+		for (const controller of this.notifications.get(taskId) ?? []) controller.abort();
+	}
+	async delegate(actor, input) {
+		await this.ready;
+		input.signal.throwIfAborted();
+		requireFusion(!actor.parentSessionId && !this.roleIsChild(actor.sessionId), "UNAUTHORIZED", "Fusion only delegates from a user root session.");
+		text(actor.sessionId, "session id", 200);
+		text(actor.project, "project identity", 8192);
+		const brief$1 = brief(input.brief), route$1 = route(input.route), target$1 = target(input.target);
+		requireFusion(input.profile === "generic" || input.profile === "writing", "INVALID_INPUT", "Unknown Fusion profile.");
+		const reserved = await this.change(async (next) => {
+			input.signal.throwIfAborted();
+			let pair = next.pairs.find((pair) => pair.leadSessionId === actor.sessionId);
+			if (pair) {
+				requireFusion(pair.project === actor.project && pair.profile === input.profile, "CONTEXT_CHANGED", "Project or profile changed. Start a new root conversation.");
+				requireFusion(!currentTask(pair) || !isWorking(currentTask(pair).state), "BUSY", "The previous Fusion task needs review, cancellation or a decision first.");
+				requireFusion(!currentTask(pair) || !this.dispatches.has(currentTask(pair).id), "ADMISSION_PENDING", "The previous native admission is still settling.");
+				requireFusion(!["pending", "conflict"].includes(currentTask(pair)?.adoption ?? "") && currentTask(pair)?.application?.state !== "pending", "ADOPTION_PENDING", "Adopt or dismiss the previous candidate before delegating again.");
+				requireFusion(currentTask(pair)?.cleanup !== "pending" && currentTask(pair)?.cleanup !== "failed", "STOP_INCOMPLETE", "Previous child cleanup must finish before delegation.");
+				requireFusion(JSON.stringify(pair.route) === JSON.stringify(route$1), "ROUTE_CHANGED", "The persistent partner uses another route. Start a new conversation to change it.");
+				if (!pair.established && pair.tasks.length && this.inspectAdmission) {
+					await this.native.stop(clone(pair), false);
+					pair.established = await this.inspectAdmission(clone(pair), input.signal) === "present";
+					input.signal.throwIfAborted();
+				}
+				requireFusion(pair.established || pair.tasks.length === 0 || this.inspectAdmission, "UNCERTAIN_ADMISSION", "Initial child admission is uncertain. Start a new conversation after inspecting the old child.");
+			} else {
+				pair = {
+					id: this.id(),
+					leadSessionId: actor.sessionId,
+					childSessionId: this.id(),
+					project: actor.project,
+					profile: input.profile,
+					route: route$1,
+					established: false,
+					tasks: [],
+					createdAt: this.now()
+				};
+				next.pairs.push(pair);
+			}
+			const task = {
+				id: this.id(),
+				revision: 1,
+				state: "dispatching",
+				brief: brief$1,
+				...target$1 ? { target: target$1 } : {},
+				candidates: [],
+				reviews: [],
+				messageIds: [],
+				dispatchId: this.id(),
+				reportIds: [],
+				delivery: "pending",
+				createdAt: this.now(),
+				updatedAt: this.now()
+			};
+			pair.tasks.push(task);
+			return {
+				pair,
+				task
+			};
+		});
+		return this.dispatch(reserved.pair, reserved.task, input.signal);
+	}
+	roleIsChild(id) {
+		return this.state.pairs.some((pair) => pair.childSessionId === id);
+	}
+	dispatch(pair, task, outerSignal) {
+		const controller = new AbortController(), generation = this.generation;
+		const controllers = this.dispatches.get(task.id) ?? /* @__PURE__ */ new Set();
+		controllers.add(controller);
+		this.dispatches.set(task.id, controllers);
+		const signal = AbortSignal.any([
+			outerSignal,
+			controller.signal,
+			this.controller.signal
+		]);
+		return this.track((async () => {
+			try {
+				signal.throwIfAborted();
+				const message = await this.native.dispatch({
+					pair: clone(pair),
+					task: clone(task),
+					prompt: this.prompt(pair, task),
+					signal
+				});
+				const admitted = await this.change((next) => {
+					const current = next.pairs.find((row) => row.id === pair.id);
+					current.established = true;
+					const row = current.tasks.find((row) => row.id === task.id);
+					const messageId = text(message.messageId, "message id", 200);
+					if (!row.messageIds.includes(messageId)) row.messageIds.push(messageId);
+					if (row.revision === task.revision) {
+						row.delivery = "accepted";
+						if (this.enabled && !this.storageFailed && generation === this.generation && row.state === "dispatching") row.state = "working";
+						row.updatedAt = this.now();
+					}
+					return {
+						task: row,
+						valid: this.enabled && !this.storageFailed && generation === this.generation && ![
+							"cancelled",
+							"failed",
+							"interrupted"
+						].includes(row.state)
+					};
+				}, true);
+				requireFusion(admitted.valid, "STALE", "Task was invalidated while its message was being admitted.");
+				return admitted.task;
+			} catch (error) {
+				await this.change((next) => {
+					const row = next.pairs.find((row) => row.id === pair.id)?.tasks.find((row) => row.id === task.id);
+					if (row && row.revision === task.revision && isWorking(row.state)) {
+						row.state = signal.aborted ? "cancelled" : "failed";
+						row.delivery = "uncertain";
+						row.updatedAt = this.now();
+						row.error = signal.aborted ? "任务已取消，未自动重试。" : "委派未确认完成，请查看执行记录后再处理。";
+					}
+				}, true);
+				const latest = this.pairFor(pair.leadSessionId)?.tasks.at(-1);
+				if (!this.enabled || latest?.id === task.id && latest.revision === task.revision && [
+					"cancelled",
+					"failed",
+					"interrupted"
+				].includes(latest.state)) try {
+					await this.native.stop(pair, false);
+				} catch {}
+				throw error;
+			} finally {
+				controllers.delete(controller);
+				if (!controllers.size) this.dispatches.delete(task.id);
+			}
+		})());
+	}
+	prompt(pair, task) {
+		return `Fusion task ${task.id}; revision ${task.revision}; dispatch ${task.dispatchId}.\nGoal: ${task.brief.goal}\nContext:\n${task.brief.context}\nConstraints:\n${task.brief.constraints.join("\n")}\nAcceptance:\n${task.brief.acceptance.join("\n")}\n` + (task.target ? `Versioned destination (do not change): ${JSON.stringify(task.target)}\n` : "") + (task.decision ? `Lead feedback: ${task.decision}\n` : "") + `Use fusion_report with this taskId and taskRevision, and a unique reportId. Submit ${pair.profile === "writing" ? "the exact prose candidate" : "a concise result with verifiable evidence"}, or request a decision. Do not claim the task is complete without reporting. Stop after reporting and wait for the Lead.`;
+	}
+	async report(actor, input) {
+		await this.ready;
+		input.signal.throwIfAborted();
+		integer(input.taskRevision, "task revision");
+		text(input.reportId, "report id", 200);
+		text(input.text, "report text", input.kind === "candidate" ? 2e5 : 16e3, input.kind === "candidate");
+		text(input.report ?? "", "report summary", 16e3, true);
+		requireFusion(input.kind === "candidate" || input.kind === "decision", "INVALID_INPUT", "Unknown report kind.");
+		const generation = this.generation;
+		const result = await this.change((next) => {
+			input.signal.throwIfAborted();
+			const pair = this.owned(next, actor, "sidekick"), task = this.task(pair, input.taskId, input.taskRevision);
+			pair.established = true;
+			const reportKey = `${task.revision}:${input.reportId}`;
+			if (task.reportIds.includes(reportKey)) {
+				const candidate = task.candidates.at(-1);
+				requireFusion(input.kind === "decision" ? task.decision === input.text : candidate?.text === input.text && candidate.report === (input.report ?? ""), "DUPLICATE_CONFLICT", "A report id cannot be reused for different content.");
+				return {
+					pair,
+					task,
+					reportKey,
+					duplicate: true
+				};
+			}
+			requireFusion(task.state === "dispatching" || task.state === "working", "STALE", "The task is no longer accepting reports.");
+			task.reportIds.push(reportKey);
+			if (input.kind === "decision") {
+				task.state = "decision";
+				task.decision = input.text;
+			} else {
+				task.candidates.push({
+					id: this.id(),
+					taskRevision: task.revision,
+					revision: task.candidates.length + 1,
+					text: input.text,
+					hash: contentHash(input.text),
+					report: input.report ?? "",
+					createdAt: this.now()
+				});
+				task.state = "review";
+			}
+			task.updatedAt = this.now();
+			return {
+				pair,
+				task,
+				reportKey,
+				duplicate: false
+			};
+		});
+		if (result.duplicate) {
+			requireFusion(result.task.notifiedReportId === result.reportKey, "NOTIFICATION_UNCERTAIN", "The report was saved, but Lead notification is not confirmed. Inspect the exact task record before any explicit recovery.");
+			return result.task;
+		}
+		const controller = new AbortController();
+		const controllers = this.notifications.get(result.task.id) ?? /* @__PURE__ */ new Set();
+		controllers.add(controller);
+		this.notifications.set(result.task.id, controllers);
+		try {
+			if (this.isCurrent(result.pair.id, result.task.id, result.task.revision, generation)) {
+				const candidate = result.task.candidates.at(-1);
+				const body = result.task.state === "decision" ? `Decision requested for ${result.task.id} revision ${result.task.revision}: ${result.task.decision}` : `Candidate ready for ${result.task.id} revision ${result.task.revision}: ${candidate.id}, sha256 ${candidate.hash}. Read the exact candidate using fusion_read before fusion_review. Report: ${candidate.report}`;
+				const signal = AbortSignal.any([controller.signal, this.controller.signal]);
+				signal.throwIfAborted();
+				await this.track(this.native.notify({
+					pair: result.pair,
+					task: result.task,
+					actor,
+					text: body,
+					signal
+				}));
+				await this.change((next) => {
+					const row = next.pairs.find((pair) => pair.id === result.pair.id)?.tasks.find((task) => task.id === result.task.id);
+					if (row?.revision === result.task.revision && isWorking(row.state)) row.notifiedReportId = result.reportKey;
+				}, true);
+			}
+		} finally {
+			controllers.delete(controller);
+			if (controllers.size === 0) this.notifications.delete(result.task.id);
+		}
+		return clone(this.state.pairs.find((pair) => pair.id === result.pair.id)?.tasks.find((task) => task.id === result.task.id) ?? result.task);
+	}
+	read(actor, taskId, candidateId) {
+		const task = this.owned(this.state, actor, "lead").tasks.find((row) => row.id === taskId);
+		requireFusion(task, "NOT_FOUND", "Unknown Fusion task.");
+		const candidate = candidateId ? task.candidates.find((row) => row.id === candidateId) : task.candidates.at(-1);
+		requireFusion(!candidateId || candidate, "NOT_FOUND", "Unknown candidate.");
+		return clone({
+			task,
+			...candidate ? { candidate } : {}
+		});
+	}
+	async review(actor, input) {
+		await this.ready;
+		input.signal.throwIfAborted();
+		text(input.feedback, "feedback", 16e3, true);
+		requireFusion([
+			"accept",
+			"revise",
+			"reject"
+		].includes(input.verdict), "INVALID_INPUT", "Unknown review verdict.");
+		const result = await this.change((next) => {
+			input.signal.throwIfAborted();
+			const pair = this.owned(next, actor, "lead"), task = this.task(pair, input.taskId, integer(input.taskRevision, "task revision"));
+			const candidate = task.candidates.at(-1);
+			requireFusion(candidate?.id === input.candidateId && candidate.hash === input.hash && candidate.taskRevision === task.revision, "STALE", "Review must reference the current exact candidate.");
+			requireFusion(task.state === "review", "STALE", "The task is not awaiting review.");
+			requireFusion(contentHash(candidate.text) === candidate.hash, "INVALID_STATE", "Candidate content does not match its stored hash.");
+			task.reviews.push({
+				candidateId: candidate.id,
+				candidateHash: candidate.hash,
+				verdict: input.verdict,
+				feedback: input.feedback,
+				createdAt: this.now()
+			});
+			task.updatedAt = this.now();
+			if (input.verdict === "accept") {
+				task.state = "accepted";
+				if (pair.profile === "writing" && task.target) task.adoption = "pending";
+			} else if (input.verdict === "reject") task.state = "cancelled";
+			else {
+				requireFusion(task.candidates.length < 16, "RETRY_LIMIT", "Revision limit reached. Keep the candidate and ask the author for direction.");
+				requireFusion(input.feedback.trim(), "INVALID_INPUT", "Revision requires actionable feedback.");
+				task.revision++;
+				task.state = "dispatching";
+				task.dispatchId = this.id();
+				task.delivery = "pending";
+				task.decision = input.feedback;
+				delete task.notifiedReportId;
+			}
+			return {
+				pair,
+				task
+			};
+		});
+		this.abortNotifications(result.task.id);
+		if (input.verdict === "revise") return this.dispatch(result.pair, result.task, input.signal);
+		return result.task;
+	}
+	async decide(actor, input) {
+		await this.ready;
+		input.signal.throwIfAborted();
+		text(input.feedback, "decision", 16e3);
+		const result = await this.change(async (next) => {
+			input.signal.throwIfAborted();
+			const pair = this.owned(next, actor, "lead"), task = this.task(pair, input.taskId, integer(input.taskRevision, "task revision"));
+			requireFusion([
+				"decision",
+				"interrupted",
+				"failed"
+			].includes(task.state), "STALE", "Only a blocked or explicitly interrupted task can resume.");
+			requireFusion(task.delivery !== "pending", "UNCERTAIN_ADMISSION", "Initial admission is still pending.");
+			if (this.inspectAdmission) {
+				await this.native.stop(clone(pair), false);
+				pair.established = await this.inspectAdmission(clone(pair), input.signal) === "present";
+				input.signal.throwIfAborted();
+				task.cleanup = "done";
+			} else requireFusion(pair.established, "UNCERTAIN_ADMISSION", "Inspect uncertain initial admission before resuming.");
+			requireFusion(task.revision < 32, "RETRY_LIMIT", "Task revision limit reached.");
+			task.revision++;
+			task.state = "dispatching";
+			task.delivery = "pending";
+			task.dispatchId = this.id();
+			task.decision = input.feedback;
+			delete task.error;
+			delete task.notifiedReportId;
+			task.updatedAt = this.now();
+			return {
+				pair,
+				task
+			};
+		});
+		this.abortNotifications(result.task.id);
+		return this.dispatch(result.pair, result.task, input.signal);
+	}
+	async cancel(actor, taskId, taskRevision, stopLead = false) {
+		await this.ready;
+		const present = this.task(this.owned(this.state, actor, "lead"), taskId, integer(taskRevision, "task revision"));
+		for (const controller of this.applications.get(present.id) ?? []) controller.abort();
+		const pair = await this.change((next) => {
+			const pair = this.owned(next, actor, "lead"), task = this.task(pair, taskId, integer(taskRevision, "task revision"));
+			requireFusion(task.application?.state !== "pending", "APPLICATION_UNCERTAIN", "Inspect the pending application before stopping this task.");
+			requireFusion(task.adoption !== "applied", "ALREADY_APPLIED", "Stopping does not undo an applied change.");
+			if (task.state === "accepted" && pair.profile === "writing" && task.target) task.adoption = "dismissed";
+			else task.state = "cancelled";
+			task.cleanup = "pending";
+			task.updatedAt = this.now();
+			return pair;
+		});
+		for (const controller of this.dispatches.get(taskId) ?? []) controller.abort();
+		this.abortNotifications(taskId);
+		try {
+			await this.track(this.native.stop(pair, stopLead));
+			await this.change((next) => {
+				this.task(this.owned(next, actor, "lead"), taskId, taskRevision).cleanup = "done";
+			}, true);
+		} catch (error) {
+			await this.change((next) => {
+				this.task(this.owned(next, actor, "lead"), taskId, taskRevision).cleanup = "failed";
+			}, true);
+			throw error;
+		}
+	}
+	async executionInterrupted(actor, reason, expected) {
+		await this.ready;
+		await this.change((next) => {
+			const pair = this.owned(next, actor, "sidekick"), task = currentTask(pair);
+			if (task && (!expected || task.id === expected.taskId && task.revision === expected.revision) && ["dispatching", "working"].includes(task.state)) {
+				task.state = "interrupted";
+				task.error = text(reason, "interruption reason", 16e3);
+				task.delivery = "uncertain";
+				task.updatedAt = this.now();
+			}
+		});
+	}
+	/** Explicit recovery only: saved content is re-notified, never dispatched to the Writer. */
+	async recover(actor, taskId, taskRevision, outerSignal) {
+		await this.ready;
+		outerSignal.throwIfAborted();
+		const result = await this.change((next) => {
+			const pair = this.owned(next, actor, "lead"), task = this.task(pair, taskId, integer(taskRevision, "task revision"));
+			requireFusion([
+				"interrupted",
+				"review",
+				"decision"
+			].includes(task.state), "STALE", "This task has no recoverable report.");
+			const reportKey = task.reportIds.at(-1);
+			requireFusion(reportKey?.startsWith(`${task.revision}:`), "NO_REPORT", "There is no saved report for this revision. Resume with feedback instead.");
+			task.state = task.candidates.at(-1)?.taskRevision === task.revision ? "review" : "decision";
+			requireFusion(task.state === "review" || task.decision, "NO_REPORT", "No saved report is available.");
+			task.updatedAt = this.now();
+			return {
+				pair,
+				task,
+				reportKey
+			};
+		});
+		const controller = new AbortController(), controllers = this.notifications.get(taskId) ?? /* @__PURE__ */ new Set();
+		controllers.add(controller);
+		this.notifications.set(taskId, controllers);
+		const signal = AbortSignal.any([
+			outerSignal,
+			controller.signal,
+			this.controller.signal
+		]);
+		try {
+			signal.throwIfAborted();
+			const candidate = result.task.candidates.at(-1);
+			const body = result.task.state === "review" ? `Recovered saved candidate for ${taskId} revision ${taskRevision}: ${candidate.id}, sha256 ${candidate.hash}. Read with fusion_read, then fusion_review. This is a repeated notification, not a new Writer result.` : `Recovered saved decision for ${taskId} revision ${taskRevision}: ${result.task.decision}`;
+			await this.track(this.native.notify({
+				pair: result.pair,
+				task: result.task,
+				actor,
+				text: body,
+				signal
+			}));
+			await this.change((next) => {
+				const task = this.task(this.owned(next, actor, "lead"), taskId, taskRevision);
+				requireFusion(["review", "decision"].includes(task.state), "STALE", "Recovery was cancelled.");
+				task.notifiedReportId = result.reportKey;
+			});
+			return this.read(actor, taskId).task;
+		} finally {
+			controllers.delete(controller);
+			if (!controllers.size) this.notifications.delete(taskId);
+		}
+	}
+	candidateAction(next, actor, input) {
+		requireFusion(input.sessionId === actor.sessionId, "UNAUTHORIZED", "Session identity mismatch.");
+		const pair = this.owned(next, actor, "lead"), task = this.task(pair, input.taskId, integer(input.taskRevision, "task revision"));
+		const candidate = task.candidates.at(-1);
+		requireFusion(candidate?.id === input.candidateId && candidate.hash === input.hash && candidate.taskRevision === task.revision, "STALE", "The exact current candidate is required.");
+		const review = task.reviews.at(-1);
+		requireFusion(review?.verdict === "accept" && review.candidateId === candidate.id && review.candidateHash === candidate.hash, "NOT_ACCEPTED", "The exact candidate has not been accepted by the Lead.");
+		requireFusion(pair.profile === "writing" && task.target && task.state === "accepted", "NOT_ACCEPTED", "The Lead must accept this writing candidate first.");
+		return {
+			pair,
+			task,
+			candidate,
+			target: task.target
+		};
+	}
+	/** Also used by status. An uncertain filesystem mutation is inspected, never replayed. */
+	async reconcile(actor, host, signal) {
+		await this.ready;
+		if (!this.pairFor(actor.sessionId)?.tasks.some((task) => task.application?.state === "pending")) return;
+		await this.change(async (next) => {
+			const pair = this.owned(next, actor, "lead");
+			for (const task of pair.tasks) {
+				const application = task.application;
+				if (application?.state !== "pending") continue;
+				const candidate = task.candidates.find((row) => row.id === application.candidateId);
+				requireFusion(task.target && candidate, "INVALID_STATE", "Incomplete application intent.");
+				await host.transact(actor, task.target, candidate, signal, async (access) => {
+					const current = await access.inspect();
+					if (current && contentHash(current.text) === application.afterHash) {
+						application.state = "applied";
+						application.version = text(current.version, "application receipt version", 8192);
+						task.adoption = "applied";
+					} else {
+						application.state = "conflict";
+						task.adoption = "conflict";
+					}
+					task.updatedAt = this.now();
+				});
+			}
+		});
+	}
+	async preview(actor, input, host, signal) {
+		await this.ready;
+		return this.change(async (next) => {
+			const { task, candidate, target } = this.candidateAction(next, actor, input);
+			requireFusion(!task.application || task.application.state === "conflict", "ALREADY_APPLIED", "This application has already started or completed.");
+			requireFusion(task.adoption !== "dismissed" && task.adoption !== "applied", "STALE", "This candidate is no longer awaiting adoption.");
+			return host.transact(actor, target, candidate, signal, async (access) => ({
+				...await access.prepare(),
+				candidateId: candidate.id,
+				hash: candidate.hash
+			}));
+		});
+	}
+	async applyCandidate(actor, input, host, outerSignal) {
+		await this.ready;
+		text(input.expectedVersion, "expected version", 8192, true);
+		const controller = new AbortController(), controllers = this.applications.get(input.taskId) ?? /* @__PURE__ */ new Set();
+		controllers.add(controller);
+		this.applications.set(input.taskId, controllers);
+		try {
+			return await this.change(async (next) => {
+				const { task, candidate, target } = this.candidateAction(next, actor, input);
+				requireFusion(task.adoption !== "dismissed", "STALE", "This candidate was dismissed.");
+				requireFusion(!task.application || task.application.state === "conflict", "ALREADY_APPLIED", "This application has already started or completed.");
+				const signal = AbortSignal.any([
+					outerSignal,
+					controller.signal,
+					this.controller.signal
+				]);
+				return host.transact(actor, target, candidate, signal, async (access) => {
+					const preview = await access.prepare();
+					requireFusion(preview.version === input.expectedVersion, "CONFLICT", "The preview version changed. Preview the current file again.");
+					signal.throwIfAborted();
+					task.application = {
+						id: this.id(),
+						candidateId: candidate.id,
+						candidateHash: candidate.hash,
+						path: preview.path,
+						beforeVersion: preview.version,
+						afterHash: contentHash(preview.after),
+						state: "pending"
+					};
+					task.adoption = "pending";
+					task.updatedAt = this.now();
+					requireFusion(JSON.stringify(next).length <= 15934464, "CAPACITY", "Fusion history has no room for the application receipt. The file was not changed.");
+					await this.persist(next);
+					signal.throwIfAborted();
+					try {
+						const receipt = await access.commit(preview.version);
+						requireFusion(receipt.path === preview.path, "INVALID_RECEIPT", "Host committed a different destination.");
+						task.application.state = "applied";
+						task.application.version = text(receipt.version, "application receipt version", 8192);
+						task.adoption = "applied";
+						task.updatedAt = this.now();
+						return task;
+					} catch (error) {
+						throw error;
+					}
+				});
+			});
+		} catch (error) {
+			if (this.active) await this.change((next) => {
+				const task = next.pairs.find((row) => row.leadSessionId === actor.sessionId && row.project === actor.project)?.tasks.at(-1), candidate = task?.candidates.at(-1);
+				if (task?.id === input.taskId && task.revision === input.taskRevision && candidate?.id === input.candidateId && candidate.hash === input.hash && task.state === "accepted" && task.adoption !== "applied" && task.adoption !== "dismissed") {
+					if (!task.application || task.application.state === "conflict") task.adoption = "conflict";
+					task.error = (error instanceof Error ? error.message : String(error)).slice(0, 16e3);
+				}
+			}).catch(() => {});
+			throw error;
+		} finally {
+			controllers.delete(controller);
+			if (!controllers.size) this.applications.delete(input.taskId);
+		}
+	}
+	async dismiss(actor, input) {
+		await this.ready;
+		return this.change((next) => {
+			const { task } = this.candidateAction(next, actor, input);
+			requireFusion(task.application?.state !== "pending" && task.adoption !== "applied", "ALREADY_APPLIED", "Inspect the application before dismissing it.");
+			task.adoption = "dismissed";
+			task.updatedAt = this.now();
+			return task;
+		});
+	}
+	/** Domain Host only: never expose an RPC that lets a browser claim a file was applied. */
+	async adoption(leadSessionId, taskId, candidateId, state) {
+		await this.ready;
+		await this.change((next) => {
+			const task = next.pairs.find((row) => row.leadSessionId === leadSessionId)?.tasks.find((row) => row.id === taskId);
+			requireFusion(task && task.state === "accepted" && task.candidates.at(-1)?.id === candidateId, "STALE", "No accepted candidate matches the Host receipt.");
+			requireFusion(task.adoption !== "applied" || state === "applied", "ALREADY_APPLIED", "An applied receipt cannot be overwritten.");
+			task.adoption = state;
+			task.updatedAt = this.now();
+		}, true);
+	}
+	/** Stops owned work only. Invalidate synchronously, then await admissions and cleanup. */
+	async dispose() {
+		if (!this.enabled) return;
+		this.enabled = false;
+		this.generation++;
+		this.controller.abort();
+		for (const controllers of this.dispatches.values()) for (const controller of controllers) controller.abort();
+		for (const taskId of this.notifications.keys()) this.abortNotifications(taskId);
+		const errors = [];
+		try {
+			await this.ready;
+			await this.change((next) => {
+				for (const pair of next.pairs) for (const task of pair.tasks) if (isWorking(task.state)) {
+					task.state = "cancelled";
+					task.cleanup = "pending";
+					task.updatedAt = this.now();
+				}
+			}, true);
+		} catch (error) {
+			errors.push(error);
+		}
+		await Promise.allSettled([...this.inFlight]);
+		const results = await Promise.allSettled(this.state.pairs.map((pair) => this.native.stop(clone(pair), false)));
+		try {
+			await this.change((next) => {
+				next.pairs.forEach((pair, index) => {
+					for (const task of pair.tasks) if (task.cleanup === "pending") task.cleanup = results[index].status === "fulfilled" ? "done" : "failed";
+				});
+			}, true);
+		} catch (error) {
+			errors.push(error);
+		}
+		for (const result of results) if (result.status === "rejected") errors.push(result.reason);
+		if (errors.length) throw new AggregateError(errors, "Fusion teardown did not complete cleanly.");
+	}
+};
+//#endregion
+//#region src/native.ts
+const sid = (id) => id;
+/** Identity is derived from the exact live Agent, never a model-supplied role or label. */
+function nativeActor(bindings, agent) {
+	requireFusion(agent && bindings.agents.get(agent.id) === agent, "UNAUTHORIZED", "A current live Agent is required.");
+	const header = agent.session.header;
+	requireFusion(typeof header.cwd === "string" && header.cwd.length > 0, "NO_WORKSPACE", "Fusion requires a session workspace.");
+	return {
+		sessionId: String(agent.id),
+		project: header.cwd,
+		...header.parentSession ? { parentSessionId: String(header.parentSession) } : {}
+	};
+}
+function leadOf(bindings, pair) {
+	const lead = bindings.agents.get(sid(pair.leadSessionId));
+	const actor = nativeActor(bindings, lead);
+	requireFusion(actor.project === pair.project && !actor.parentSessionId, "UNAUTHORIZED", "The stored Fusion parent does not match this live workspace.");
+	return lead;
+}
+function ownedChild(bindings, pair) {
+	const child = bindings.agents.get(sid(pair.childSessionId));
+	if (!child) return void 0;
+	const actor = nativeActor(bindings, child);
+	requireFusion(actor.parentSessionId === pair.leadSessionId && actor.project === pair.project, "UNAUTHORIZED", "The live child does not belong to this Fusion pair.");
+	return child;
+}
+/** Adapter only: the pinned native continuation manager owns creation, inboxes and cold resume. */
+function createNativeBridge(bindings, composition) {
+	return {
+		async dispatch({ pair, prompt, signal }) {
+			signal.throwIfAborted();
+			const lead = leadOf(bindings, pair);
+			if (pair.established) {
+				await composition.verifyContinuation?.(pair, signal);
+				signal.throwIfAborted();
+				const messageId = await bindings.subagents.sendMessage(lead, sid(pair.childSessionId), [{
+					type: "text",
+					text: prompt
+				}], { signal });
+				return { messageId: String(messageId) };
+			}
+			const provider = bindings.subagents.getProvider("spawn");
+			requireFusion(provider?.prepareContinuable && provider.capabilities.agentOptions && provider.capabilities.persona && provider.capabilities.toolFilter, "UNSUPPORTED_CAPABILITY", "Fusion requires the native spawn provider with continuable, model, persona and tool-filter support.");
+			requireFusion(!provider.inheritsParentContext, "CONTEXT_NOT_ISOLATED", "The Fusion provider must not copy the parent transcript.");
+			requireFusion(!bindings.agents.get(sid(pair.childSessionId)), "IDENTITY_CONFLICT", "The reserved child identity is already live.");
+			const tools = [...new Set(composition.tools(lead, pair))];
+			requireFusion(tools.includes("fusion_report"), "INVALID_COMPOSITION", "The child must have its report tool.");
+			requireFusion(!tools.includes("fusion_delegate") && !tools.includes("fusion_review"), "INVALID_COMPOSITION", "The child cannot own Lead controls.");
+			const toolFilter = pair.profile === "generic" && composition.scopedReport ? void 0 : { allow: composition.scopedReport ? tools.filter((name) => name !== "fusion_report") : tools };
+			const agentOptions = {
+				provider: pair.route.provider,
+				model: pair.route.model,
+				reasoningEffort: pair.route.reasoningEffort
+			};
+			const started = await bindings.subagents.startContinuable({
+				provider: "spawn",
+				label: pair.profile === "writing" ? "执笔" : "Fusion Sidekick",
+				childId: sid(pair.childSessionId),
+				request: {
+					parent: lead,
+					prompt: [{
+						type: "text",
+						text: prompt
+					}],
+					agentOptions,
+					persona: composition.persona(pair),
+					...toolFilter ? { toolFilter } : {},
+					maxDepth: 1
+				},
+				signal
+			});
+			requireFusion(String(started.childId) === pair.childSessionId, "IDENTITY_CONFLICT", "The native provider returned another child identity.");
+			return { messageId: String(started.messageId) };
+		},
+		async notify({ pair, task, actor, text, signal }) {
+			signal.throwIfAborted();
+			const lead = leadOf(bindings, pair);
+			const content = [{
+				type: "text",
+				text: `${`[fusion:${pair.id}:${task.id}:${task.revision}]`}\n${text}`
+			}];
+			let messageId;
+			if (actor.sessionId === pair.leadSessionId && !actor.parentSessionId && actor.project === pair.project) {
+				messageId = randomUUID();
+				lead.followup({
+					id: messageId,
+					role: "user",
+					source: {
+						kind: "plugin:@klarkxy/dsh-fusion",
+						plugin: "@klarkxy/dsh-fusion"
+					},
+					content
+				});
+			} else {
+				const child = ownedChild(bindings, pair);
+				requireFusion(child && String(child.id) === actor.sessionId && actor.parentSessionId === pair.leadSessionId, "UNAUTHORIZED", "Only the current bound child can report to the Lead.");
+				messageId = await bindings.subagents.sendMessage(child, sid(pair.leadSessionId), content, { signal });
+			}
+			if (signal.aborted) {
+				lead.inbox.remove?.(messageId);
+				signal.throwIfAborted();
+			}
+		},
+		async stop(pair, stopLead) {
+			const child = ownedChild(bindings, pair);
+			const lead = bindings.agents.get(sid(pair.leadSessionId));
+			if (lead) {
+				leadOf(bindings, pair);
+				const marker = `[fusion:${pair.id}:`;
+				for (const message of [...lead.inbox.nextStep ?? [], ...lead.inbox.nextTurn ?? []]) if (isOwnedChildNotice(message.source, pair.childSessionId) || message.source.kind === "plugin:@klarkxy/dsh-fusion" && message.content.some((block) => block.type === "text" && block.text.includes(marker))) lead.inbox.remove(message.id);
+			}
+			child?.inbox.clear();
+			if (stopLead && lead) lead.cancel({ kind: "user" }, { keepInbox: true });
+			if (lead) await bindings.subagents.drainContinuableChildren(lead, [sid(pair.childSessionId)]);
+			else if (child) {
+				bindings.subagents.interrupt(sid(pair.childSessionId), {
+					kind: "user",
+					parentSessionId: sid(pair.leadSessionId)
+				});
+				await child.whenIdle();
+				requireFusion(false, "PARENT_UNAVAILABLE", "Child execution stopped, but its parent must be restored before ownership cleanup can be confirmed.");
+			}
+		}
+	};
+}
+//#endregion
+//#region src/tools.ts
+const taskFields = {
+	taskId: {
+		type: "string",
+		required: true
+	},
+	taskRevision: {
+		type: "integer",
+		required: true
+	}
+};
+const candidateFields = {
+	...taskFields,
+	candidateId: {
+		type: "string",
+		required: true
+	},
+	hash: {
+		type: "string",
+		required: true
+	}
+};
+const output = {
+	schema: { type: "string" },
+	render: (_args, value) => [{
+		type: "text",
+		text: String(value)
+	}]
+};
+/** Exact execution Agent identity is bound at registration and checked again on every call. */
+function fusionTools(runtime, agent, sidekick) {
+	const bound = (exec) => {
+		requireFusion(exec.agent === agent, "UNAUTHORIZED", "Fusion tools cannot be borrowed by another Agent.");
+		return runtime.actor(agent);
+	};
+	if (sidekick) return [defineTool({
+		name: "fusion_report",
+		description: "Report the exact candidate or a decision request for your current Fusion task. Never write the manuscript. Use a unique reportId; do not regenerate or resend after acknowledgement.",
+		parameters: {
+			...taskFields,
+			reportId: {
+				type: "string",
+				required: true
+			},
+			kind: {
+				type: "string",
+				enum: ["candidate", "decision"],
+				required: true
+			},
+			text: {
+				type: "string",
+				required: true
+			},
+			report: { type: "string" }
+		},
+		output,
+		async execute(args, exec) {
+			return JSON.stringify(await runtime.service.report(bound(exec), {
+				...args,
+				signal: exec.signal
+			}));
+		}
+	})];
+	return [
+		defineTool({
+			name: "fusion_delegate",
+			description: "Delegate one bounded task to the same persistent Sidekick. In writing sessions the Writer authors exact prose; provide the original versioned target from read. Wait for its report, then read and review. Generic tasks retain ordinary execution tools; explicitly cancel before takeover.",
+			parameters: {
+				title: {
+					type: "string",
+					required: true
+				},
+				goal: {
+					type: "string",
+					required: true
+				},
+				context: { type: "string" },
+				constraints: {
+					type: "array",
+					items: { type: "string" }
+				},
+				acceptance: {
+					type: "array",
+					items: { type: "string" }
+				},
+				target: {
+					type: "object",
+					additionalProperties: false,
+					properties: {
+						kind: {
+							type: "string",
+							enum: ["edit", "create"],
+							required: true
+						},
+						path: {
+							type: "string",
+							required: true
+						},
+						oldText: { type: "string" },
+						targetVersion: { type: "string" },
+						basis: {
+							type: "array",
+							items: {
+								type: "object",
+								properties: {
+									path: {
+										type: "string",
+										required: true
+									},
+									version: {
+										type: "string",
+										required: true
+									},
+									label: { type: "string" }
+								},
+								additionalProperties: false
+							}
+						}
+					},
+					description: "Writing target: edit requires original targetVersion and unique exact oldText; Writer text replaces that fragment. create requires a nonexistent .md/.txt path; Writer text becomes full content. basis lists original context read versions. No replacement text is accepted here."
+				}
+			},
+			output,
+			async execute(args, exec) {
+				bound(exec);
+				return JSON.stringify(await runtime.delegate(agent, args, exec.signal));
+			}
+		}),
+		defineTool({
+			name: "fusion_read",
+			description: "Read the saved exact Sidekick candidate and its hash. Review this content without rewriting it.",
+			parameters: {
+				taskId: {
+					type: "string",
+					required: true
+				},
+				candidateId: { type: "string" }
+			},
+			output,
+			async execute(args, exec) {
+				return JSON.stringify(runtime.service.read(bound(exec), args.taskId, args.candidateId));
+			}
+		}),
+		defineTool({
+			name: "fusion_review",
+			description: "Review the exact candidate id and hash. accept is model review only; the author still decides manuscript adoption. revise requires concrete feedback. reject ends the task.",
+			parameters: {
+				...candidateFields,
+				verdict: {
+					type: "string",
+					enum: [
+						"accept",
+						"revise",
+						"reject"
+					],
+					required: true
+				},
+				feedback: {
+					type: "string",
+					required: true
+				}
+			},
+			output,
+			async execute(args, exec) {
+				return JSON.stringify(await runtime.service.review(bound(exec), {
+					...args,
+					signal: exec.signal
+				}));
+			}
+		}),
+		defineTool({
+			name: "fusion_decide",
+			description: "Resolve a Sidekick decision or explicitly resume an interrupted task with feedback, reusing its persistent session.",
+			parameters: {
+				...taskFields,
+				feedback: {
+					type: "string",
+					required: true
+				}
+			},
+			output,
+			async execute(args, exec) {
+				return JSON.stringify(await runtime.service.decide(bound(exec), {
+					...args,
+					signal: exec.signal
+				}));
+			}
+		}),
+		defineTool({
+			name: "fusion_cancel",
+			description: "Cancel the owned Sidekick task before explicit takeover. This preserves unrelated child sessions and does not undo files already applied.",
+			parameters: taskFields,
+			output,
+			async execute(args, exec) {
+				const actor = bound(exec);
+				await runtime.service.cancel(actor, args.taskId, args.taskRevision);
+				return "Fusion task cancelled; takeover is now explicit.";
+			}
+		})
+	];
+}
+//#endregion
+//#region src/runtime.ts
+var FusionRuntime = class {
+	service;
+	ctx;
+	ai;
+	disposers = [];
+	installed = /* @__PURE__ */ new Map();
+	pendingNoticeClaims = /* @__PURE__ */ new Set();
+	closing;
+	constructor(ctx, store, ai) {
+		this.ctx = ctx;
+		this.ai = ai;
+		const native = createNativeBridge({
+			agents: ctx.agents,
+			subagents: ctx.subagents
+		}, {
+			scopedReport: true,
+			verifyContinuation: async (pair, signal) => {
+				requireFusion(await this.inspectAdmission(pair, signal) === "present", "CHILD_MISSING", "The persistent Sidekick is missing. Explicitly resume to inspect recovery.");
+			},
+			tools: (parent, pair) => this.childTools(parent, pair),
+			persona: (pair) => pair.profile === "writing" ? "You are the persistent Fusion Writer. Author exact prose candidates for the assigned brief and captured destination. You may inspect allowed context, but must never mutate manuscript files. Report via fusion_report; ask a decision when blocked. Do not delegate, contact the user directly, or treat rejected drafts as story facts. Stop after reporting." : "You are the persistent Fusion Sidekick. Execute only the assigned bounded task using native permissions. Report exact outcomes and verifiable evidence via fusion_report; report decisions when blocked. Never recursively enable Fusion or take over the Lead. Stop after reporting."
+		});
+		this.service = new FusionService({
+			store,
+			native,
+			inspectAdmission: (pair, signal) => this.inspectAdmission(pair, signal)
+		});
+	}
+	async inspectAdmission(pair, signal) {
+		signal.throwIfAborted();
+		const entry = (await this.ctx.subagents.listChildren(pair.leadSessionId, signal)).find((row) => String(row.id) === pair.childSessionId);
+		let observation;
+		try {
+			observation = await this.ctx.sessionQuery.observeSession(pair.childSessionId, {
+				signal,
+				projectionMode: "all"
+			});
+		} catch (error) {
+			if (error && typeof error === "object" && "code" in error && error.code === "SESSION_QUERY_SESSION_NOT_FOUND" && !entry && !this.ctx.agents.get(pair.childSessionId)) return "absent";
+			throw error;
+		}
+		try {
+			const header = observation.header, descriptor = foldSubagentDescriptor(observation.events);
+			requireFusion(String(header.id) === pair.childSessionId && String(header.parentSession) === pair.leadSessionId && header.cwd === pair.project, "IDENTITY_CONFLICT", "The native Sidekick does not match this pair and workspace.");
+			requireFusion(descriptor?.mode === "continuable" && descriptor.provider === "spawn" && (!entry || entry.mode === "continuable"), "UNCERTAIN_ADMISSION", "The saved child has no supported native continuation descriptor.");
+			requireFusion(descriptor.agentProvider === pair.route.provider && descriptor.agentModel === pair.route.model && descriptor.agentReasoningEffort === pair.route.reasoningEffort, "ROUTE_CHANGED", "The native Sidekick route differs from its pinned Fusion route.");
+			const selected = observation.projections?.values;
+			if (selected?.modelSelection?.next) this.checkRoute(pair, selected.modelSelection.next);
+			const live = this.ctx.agents.get(pair.childSessionId);
+			if (live) this.checkRoute(pair, live.options);
+			return "present";
+		} finally {
+			observation[Symbol.dispose]();
+		}
+	}
+	checkRoute(pair, route) {
+		requireFusion(route.provider === pair.route.provider && route.model === pair.route.model && route.reasoningEffort === pair.route.reasoningEffort, "ROUTE_CHANGED", "The Sidekick model changed outside Fusion. Restore its pinned route before continuing.");
+	}
+	actor(agent) {
+		requireFusion(this.service.active, "DISABLED", "Fusion is disabled.");
+		return nativeActor({
+			agents: this.ctx.agents,
+			subagents: this.ctx.subagents
+		}, agent);
+	}
+	writing() {
+		return this.ctx.get("fusionWriting");
+	}
+	profile(agent, pair) {
+		const domain = this.writing();
+		requireFusion(domain || !String(agent.session.header.agentPreset ?? "").startsWith("dsh-editor"), "DOMAIN_UNAVAILABLE", "The Editor writing domain is unavailable; delegation is blocked until it is restored.");
+		if (pair?.profile === "writing") {
+			requireFusion(domain && domain.matches(agent.session.header), "DOMAIN_UNAVAILABLE", "The writing domain is unavailable or this conversation changed writing mode.");
+			return "writing";
+		}
+		return domain?.matches(agent.session.header) ? "writing" : "generic";
+	}
+	childTools(parent, pair) {
+		if (pair.profile !== "writing") return ["fusion_report"];
+		const available = parent.ctx.tools.schemas(parent).map((tool) => tool.name).filter((name) => name !== "run_code" && !FUSION_TOOLS.includes(name));
+		this.profile(parent, pair);
+		const allow = new Set(this.writing().writerTools);
+		return [...available.filter((name) => allow.has(name)), "fusion_report"];
+	}
+	async start() {
+		await this.service.initialized();
+		const scope = this.ai.activate(FUSION_PLUGIN);
+		this.disposers.push(() => scope.dispose());
+		this.disposers.push(scope.registerPurpose({
+			id: FUSION_PURPOSE,
+			label: "Fusion 持久搭档",
+			defaultTarget: {
+				kind: "role",
+				role: "normal"
+			}
+		}));
+		this.disposers.push(this.ctx.on("agent/created", async ({ agent }) => {
+			await this.install(agent);
+		}, { global: true }));
+		this.disposers.push(this.ctx.on("agent/disposed", ({ agent }) => {
+			this.uninstall(agent);
+		}, { global: true }));
+		for (const agent of this.ctx.agents.list()) await this.install(agent);
+	}
+	async install(agent) {
+		if (this.installed.has(agent) || !this.service.active) return;
+		const header = agent.session.header, pair = this.service.pairFor(String(agent.id));
+		const sidekick = pair?.childSessionId === String(agent.id);
+		const root = !header.parentSession;
+		const disposers = [];
+		this.installed.set(agent, disposers);
+		try {
+			disposers.push(agent.ctx.tools.guard((exec) => {
+				if (exec.agent !== agent) return "Fusion execution identity mismatch.";
+				const livePair = this.service.pairFor(String(agent.id));
+				if (!this.service.active) return sidekick || FUSION_TOOLS.includes(exec.name) ? "Fusion is disabled." : void 0;
+				if (!root && !sidekick) return FUSION_TOOLS.includes(exec.name) ? "Only the owned Fusion Sidekick may report." : void 0;
+				if (sidekick) {
+					if (!livePair || livePair.childSessionId !== String(agent.id) || String(header.parentSession) !== livePair.leadSessionId || header.cwd !== livePair.project) return "Fusion child identity changed.";
+					const task = livePair.tasks.at(-1);
+					if (!task || !["working", "dispatching"].includes(task.state)) return "The Fusion task is no longer accepting execution.";
+					if (exec.name === "fusion_report" || exec.name === "run_code") return void 0;
+					if (FUSION_TOOLS.includes(exec.name)) return "Sidekick cannot control the Lead.";
+					if (livePair.profile === "writing" && !this.writing()?.writerTools.includes(exec.name)) return "Writer tools are restricted to the writing domain read surface.";
+					if (livePair.profile === "generic") {
+						const lead = this.ctx.agents.get(livePair.leadSessionId);
+						if (!lead || lead.session.header.parentSession || lead.session.header.cwd !== livePair.project) return "The Fusion Lead workspace is unavailable or changed.";
+						if (!lead.ctx.tools.get(exec.name, lead)) return "This capability is not available to the Fusion Lead.";
+					}
+					return;
+				}
+				if (exec.name === "fusion_report") return "Only the owned Sidekick may report.";
+				if (exec.name === "run_code") return void 0;
+				try {
+					if (this.profile(agent, livePair) === "writing" && !FUSION_TOOLS.includes(exec.name) && !this.writing().allowLeadTool(exec.name, exec.arguments)) return "Delegate prose to the Fusion Writer; the author adopts the exact candidate.";
+				} catch {
+					return "The Fusion writing domain is unavailable; execution is blocked until restored.";
+				}
+			}));
+			if (root) {
+				const claims = /* @__PURE__ */ new Map();
+				disposers.push(agent.ctx.on("agent/inbox/claimed", ({ message, turn }) => {
+					const pair = this.service.pairFor(String(agent.id));
+					if (!pair || !isOwnedChildNotice(message.source, pair.childSessionId) || claims.has(turn)) return;
+					let resolve;
+					const pending = new Promise((done) => {
+						resolve = done;
+					});
+					this.pendingNoticeClaims.add(pending);
+					claims.set(turn, () => {
+						claims.delete(turn);
+						this.pendingNoticeClaims.delete(pending);
+						resolve();
+					});
+				}));
+				disposers.push(agent.ctx.on("session/event", (_session, event) => {
+					if (event.type === "turn/end") claims.get(event.data.turn)?.();
+				}));
+				disposers.push(() => {
+					for (const finish of [...claims.values()]) finish();
+				});
+				const discard = (message) => {
+					const pair = this.service.pairFor(String(agent.id));
+					if (!pair || !isOwnedChildNotice(message.source, pair.childSessionId)) return false;
+					if (message.source.kind === "subagent-settled") return true;
+					const task = pair.tasks.at(-1);
+					return !this.service.active || !task || !["review", "decision"].includes(task.state) || !message.content.some((block) => block.type === "text" && block.text.includes(`[fusion:${pair.id}:${task.id}:${task.revision}]`));
+				};
+				disposers.push(agent.ctx.on("agent/pre-step", async (payload, next) => {
+					const newTurn = payload.step === 1;
+					const rejectOwnedWake = newTurn && payload.messages.length > 0 && payload.messages.every(discard);
+					claims.get(payload.turn)?.();
+					if (rejectOwnedWake) return { kind: "reject" };
+					const decision = await next();
+					if (decision.kind === "reject") return decision;
+					const messages = decision.messages.filter((message) => !discard(message));
+					return newTurn && decision.messages.length > 0 && messages.length === 0 ? { kind: "reject" } : {
+						...decision,
+						messages
+					};
+				}, { prepend: true }));
+			}
+			if (!root && !sidekick) return;
+			if (sidekick) {
+				requireFusion(pair && header.cwd === pair.project && String(header.parentSession) === pair.leadSessionId, "UNAUTHORIZED", "Stored Writer identity does not match the native child.");
+				if (pair.profile === "writing") {
+					const registry = this.ctx.get("workspaceRegistry");
+					const parent = this.ctx.sessions.get(pair.leadSessionId);
+					requireFusion(registry && parent && parent.header.cwd === pair.project && !parent.header.parentSession, "WORKSPACE_UNAVAILABLE", "The Writer requires its real Lead workspace.");
+					const workspace = await registry.resolveByPath(pair.project);
+					requireFusion(workspace && workspace.sessionIds.some((id) => String(id) === pair.leadSessionId), "WORKSPACE_MISMATCH", "The Lead is not attached to this workspace.");
+					await workspace.attachSession(agent.id);
+					this.actor(agent);
+				}
+				const turns = /* @__PURE__ */ new Map();
+				disposers.push(agent.ctx.on("session/event", (_session, event) => {
+					if (event.type === "turn/start") {
+						const task = this.service.pairFor(String(agent.id))?.tasks.at(-1);
+						if (task) turns.set(event.data.turn, {
+							taskId: task.id,
+							revision: task.revision
+						});
+					}
+					if (event.type === "turn/end") {
+						const expected = turns.get(event.data.turn);
+						turns.delete(event.data.turn);
+						if (!expected || !this.service.active) return;
+						const reason = event.data.reason.kind === "error" ? event.data.reason.error.message : `The Sidekick turn ended (${event.data.reason.kind}) without a saved report. Inspect its session before resuming.`;
+						this.service.executionInterrupted(this.actor(agent), reason, expected).catch((error) => this.ctx.logger.warn("Fusion could not save child settlement", error));
+					}
+				}));
+				this.checkRoute(pair, agent.options);
+				disposers.push(agent.ctx.on("agent/request", async (_payload, next) => {
+					const config = await next();
+					try {
+						this.checkRoute(pair, config);
+					} catch (error) {
+						await this.service.executionInterrupted(this.actor(agent), error instanceof Error ? error.message : String(error));
+						throw error;
+					}
+					return config;
+				}, { prepend: true }));
+				if (pair.profile === "writing") requireFusion(this.writing(), "DOMAIN_UNAVAILABLE", "Writing domain required for the existing Writer.");
+			}
+			for (const tool of fusionTools(this, agent, sidekick)) disposers.push(agent.ctx.tools.register(tool));
+			if (root) disposers.push(agent.ctx.systemPrompt.section({
+				name: "fusion:lead",
+				order: 95,
+				text: "Fusion collaboration is enabled. You are the Lead in the original user conversation. Discuss, plan and review; use fusion_delegate for bounded Sidekick work. Only one task may be active. Read its exact saved candidate with fusion_read before fusion_review. Accept means model review, never author file adoption. In writing modes, delegate prose editing/creation with its original read versions; do not rewrite the Writer candidate while forwarding it. Resolve decisions with fusion_decide. For explicit takeover cancel the task first with fusion_cancel. Ordinary generic native tools remain available. Existing model route stays pinned to this pair. Never create another Fusion pair from child sessions."
+			}));
+		} catch (error) {
+			this.uninstall(agent);
+			throw error;
+		}
+	}
+	uninstall(agent) {
+		const disposers = this.installed.get(agent);
+		this.installed.delete(agent);
+		for (const dispose of disposers?.reverse() ?? []) dispose();
+	}
+	async delegate(agent, input, signal) {
+		const actor = this.actor(agent), row = object(input), pair = this.service.pairFor(actor.sessionId);
+		requireFusion(!actor.parentSessionId, "UNAUTHORIZED", "Only root sessions delegate.");
+		const profile = this.profile(agent, pair);
+		const route = pair?.route ?? await this.ai.resolve("fusion.sidekick", actor.sessionId);
+		signal.throwIfAborted();
+		this.actor(agent);
+		const target = profile === "writing" ? await this.writing().capture(actor, row.target, signal) : void 0;
+		signal.throwIfAborted();
+		this.actor(agent);
+		return this.service.delegate(actor, {
+			profile,
+			route: {
+				provider: route.provider,
+				model: route.model,
+				...route.reasoningEffort ? { reasoningEffort: route.reasoningEffort } : {}
+			},
+			brief: brief(row),
+			...target ? { target } : {},
+			signal
+		});
+	}
+	rpcActor(sessionId) {
+		const session = this.ctx.sessions.get(sessionId);
+		requireFusion(session && String(session.id) === sessionId, "SESSION_NOT_FOUND", "The native session is not loaded.");
+		requireFusion(!session.header.parentSession && this.service.role(sessionId) !== "sidekick", "UNAUTHORIZED", "A child session cannot act as the Lead.");
+		const project = text(session.header.cwd, "session workspace", 8192);
+		const pair = this.service.pairFor(sessionId);
+		requireFusion(!pair || pair.project === project, "CONTEXT_CHANGED", "The session workspace differs from the Fusion pair.");
+		return {
+			actor: {
+				sessionId,
+				project
+			},
+			session
+		};
+	}
+	async rpc(endpoint, payload, signal) {
+		await this.service.initialized();
+		signal.throwIfAborted();
+		requireFusion(this.service.active, "DISABLED", "Fusion is disabled.");
+		const row = object(payload), sessionId = text(row.sessionId, "session id", 200);
+		const { actor, session } = this.rpcActor(sessionId);
+		const pair = this.service.pairFor(sessionId), profile = this.profile({ session }, pair);
+		const domain = profile === "writing" ? this.writing() : void 0;
+		if (domain) await this.service.reconcile(actor, domain, signal);
+		signal.throwIfAborted();
+		this.rpcActor(sessionId);
+		if (endpoint === "status") {
+			let error;
+			if (!pair) try {
+				await this.ai.resolve(FUSION_PURPOSE, sessionId);
+			} catch (cause) {
+				error = cause instanceof Error ? cause.message : String(cause);
+			}
+			const current = this.service.pairFor(sessionId);
+			return {
+				available: true,
+				configured: !error,
+				profile,
+				revision: this.service.snapshot().revision,
+				...error ? { error } : {},
+				...current ? { pair: current } : {},
+				usage: {
+					leadTokens: null,
+					sidekickTokens: null,
+					cost: null
+				},
+				activity: {
+					lead: this.ctx.agents.get(sessionId)?.status ?? "idle",
+					sidekick: current ? this.ctx.agents.get(current.childSessionId)?.status ?? "idle" : "idle"
+				}
+			};
+		}
+		const taskId = text(row.taskId, "task id", 200), taskRevision = integer(row.taskRevision, "task revision");
+		if (endpoint === "cancel") {
+			await this.service.cancel(actor, taskId, taskRevision, true);
+			return null;
+		}
+		if (endpoint === "resume") return this.service.decide(actor, {
+			taskId,
+			taskRevision,
+			feedback: text(row.feedback, "feedback", 16e3),
+			signal
+		});
+		if (endpoint === "recover") return this.service.recover(actor, taskId, taskRevision, signal);
+		requireFusion(domain, "DOMAIN_UNAVAILABLE", "File adoption requires a writing domain.");
+		const action = {
+			sessionId,
+			taskId,
+			taskRevision,
+			candidateId: text(row.candidateId, "candidate id", 200),
+			hash: text(row.hash, "candidate hash", 64)
+		};
+		if (endpoint === "preview") return this.service.preview(actor, action, domain, signal);
+		if (endpoint === "apply") return this.service.applyCandidate(actor, {
+			...action,
+			expectedVersion: text(row.expectedVersion, "expected version", 8192, true)
+		}, domain, signal);
+		if (endpoint === "dismiss") return this.service.dismiss(actor, action);
+		requireFusion(false, "NOT_FOUND", "Unknown Fusion endpoint.");
+	}
+	dispose() {
+		if (this.closing) return this.closing;
+		this.closing = (async () => {
+			try {
+				await this.service.dispose();
+			} finally {
+				for (const agent of this.installed.keys()) {
+					const pair = this.service.pairFor(String(agent.id));
+					if (!pair || pair.leadSessionId !== String(agent.id) || this.ctx.agents.get(agent.id) !== agent) continue;
+					for (const message of [...agent.inbox.nextStep, ...agent.inbox.nextTurn]) if (isOwnedChildNotice(message.source, pair.childSessionId)) agent.inbox.remove(message.id);
+				}
+				while (this.pendingNoticeClaims.size) await Promise.all([...this.pendingNoticeClaims]);
+				for (const agent of [...this.installed.keys()]) this.uninstall(agent);
+				for (const dispose of this.disposers.reverse()) dispose();
+			}
+		})();
+		return this.closing;
+	}
+};
+//#endregion
+//#region src/index.ts
+const name = FUSION_PLUGIN;
+const inject = [
+	"agents",
+	"subagents",
+	"tools",
+	"systemPrompt",
+	"sessions",
+	"sessionQuery",
+	"sessionProjections",
+	"storageDomain",
+	"aiServices",
+	"connection",
+	"webServer"
+];
+async function apply(ctx) {
+	const domain = await ctx.storageDomain.open(fusionDomain);
+	let runtime;
+	try {
+		runtime = new FusionRuntime(ctx, createFusionStore(domain.table("state")), ctx.get("aiServices"));
+		await runtime.start();
+	} catch (error) {
+		if (runtime) await runtime.dispose().catch(() => {});
+		await domain.close();
+		throw error;
+	}
+	const activeRuntime = runtime;
+	ctx.effect(() => async () => {
+		try {
+			await activeRuntime.dispose();
+		} finally {
+			await domain.close();
+		}
+	}, "fusion.dispose");
+	ctx.provide("fusion", activeRuntime);
+	ctx.effect(() => registerHostRpc(ctx, FUSION_RPC_CHANNEL, async (endpoint, payload, signal) => {
+		try {
+			return {
+				ok: true,
+				value: await activeRuntime.rpc(endpoint, payload, signal)
+			};
+		} catch (error) {
+			return {
+				ok: false,
+				error: {
+					code: error instanceof FusionError ? error.code : "FAILED",
+					message: error instanceof Error ? error.message : String(error)
+				}
+			};
+		}
+	}), "fusion.rpc");
+}
+//#endregion
+export { FusionRuntime, apply, inject, name };
+
+//# sourceMappingURL=index.js.map