@khorsheed/dsh-room 0.1.0

package/lib/index.js

@@ -0,0 +1,3231 @@
+import { a as memberId, c as pendingInstructions, d as rosterStaleSince, f as replayDeliveries, i as isRoomLog, l as previousCursor, n as ROOM_EVENT_TYPES, o as parseMentions, r as coordinatorMember, s as parseRelayDirective, t as MAIN_AGENT_MEMBER, u as replay } from "./journal-CuRnWk66.js";
+import { createHash, randomUUID } from "node:crypto";
+import { SessionId } from "@deepseek-ai/dsh-session";
+import { createUserMessage } from "@deepseek-ai/dsh-llm";
+import { Remote, TypertRemoteService } from "@deepseek-ai/dsh-typert-protocol";
+//#region lib/types/plan.js
+const nonempty = (value, field) => {
+	if (typeof value !== "string" || value.trim() === "" || value.length > 32e3) throw new Error(`${field} must be non-empty and at most 32000 characters`);
+};
+const identifier = (value) => {
+	if (typeof value !== "string" || !/^[a-zA-Z0-9][a-zA-Z0-9_.:-]{0,127}$/.test(value)) throw new Error("Invalid plan identity");
+};
+const references = (values, field, required = false) => {
+	if (!Array.isArray(values) || values.length > 100 || required && values.length === 0) throw new Error(`${field} requires ${required ? "1" : "0"}–100 entries`);
+	for (const value of values) nonempty(value, field);
+};
+function evidence(value) {
+	nonempty(value.summary, "Evidence summary");
+	references(value.references, "Evidence references", true);
+	references(value.artifacts, "Artifact locations");
+}
+function validateBudget(value) {
+	for (const [key, maximum] of [
+		["maxParallel", 8],
+		["maxAttempts", 100],
+		["maxAttemptsPerTask", 10],
+		["maxActiveMs", 864e5]
+	]) if (!Number.isSafeInteger(value[key]) || value[key] < 1 || value[key] > maximum) throw new Error(`Invalid goal budget ${key}`);
+}
+const clone = (plan) => structuredClone(plan);
+function stopClock(plan, now) {
+	if (plan.resumedAt !== void 0) plan.activeMs += Math.max(0, now - plan.resumedAt);
+	delete plan.resumedAt;
+}
+function activePlanMs(plan, now) {
+	return plan.activeMs + (plan.resumedAt === void 0 ? 0 : Math.max(0, now - plan.resumedAt));
+}
+function latestAttempt(task) {
+	return task.attempts.at(-1);
+}
+function acceptedTask(plan, taskId) {
+	const task = plan.tasks.find((task) => task.id === taskId);
+	if (task === void 0) return false;
+	if (task.kind === "task") return task.status === "accepted";
+	const children = plan.tasks.filter((child) => child.parentId === task.id);
+	return children.length > 0 && children.every((child) => acceptedTask(plan, child.id));
+}
+function dependenciesOf(plan, task) {
+	const dependencies = [...task.dependsOn];
+	const seen = /* @__PURE__ */ new Set([task.id]);
+	let parentId = task.parentId;
+	while (parentId !== void 0) {
+		if (seen.has(parentId)) throw new Error("Parent cycle");
+		seen.add(parentId);
+		const parent = plan.tasks.find((task) => task.id === parentId);
+		if (parent === void 0) throw new Error("Missing parent");
+		dependencies.push(...parent.dependsOn);
+		parentId = parent.parentId;
+	}
+	return dependencies;
+}
+/** Accepted leaves behind direct and inherited group prerequisites, once each. */
+function dependencyResults(plan, task) {
+	const leaves = /* @__PURE__ */ new Map();
+	const visit = (id) => {
+		const dependency = plan.tasks.find((candidate) => candidate.id === id);
+		if (dependency === void 0 || !acceptedTask(plan, id)) return;
+		if (dependency.kind === "task") leaves.set(id, dependency);
+		else for (const child of plan.tasks.filter((candidate) => candidate.parentId === id)) visit(child.id);
+	};
+	for (const id of dependenciesOf(plan, task)) visit(id);
+	return [...leaves.values()].map((dependency) => {
+		const submission = dependency.attempts.at(-1)?.submission;
+		return {
+			taskId: dependency.id,
+			...submission === void 0 ? {} : { submission }
+		};
+	});
+}
+function readyPlanTasks(plan) {
+	if (plan.status !== "running") return [];
+	return plan.tasks.filter((task) => task.kind === "task" && task.status === "pending" && dependenciesOf(plan, task).every((id) => acceptedTask(plan, id)));
+}
+function activePlanAttempts(plan) {
+	return plan.tasks.flatMap((task) => task.attempts.filter((attempt) => attempt.settledAt === void 0 && [
+		"queued",
+		"running",
+		"submitted",
+		"uncertain"
+	].includes(attempt.status)));
+}
+function taskAndAttempt(plan, taskId, attemptId) {
+	const task = plan.tasks.find((task) => task.id === taskId);
+	const attempt = task?.attempts.at(-1);
+	if (task === void 0 || attempt?.id !== attemptId) throw new Error("Attempt is missing or superseded");
+	return [task, attempt];
+}
+function validateGraph(plan, memberIds) {
+	const stages = /* @__PURE__ */ new Set();
+	for (const stage of plan.stages) {
+		identifier(stage.id);
+		nonempty(stage.title, "Stage title");
+		if (stages.has(stage.id)) throw new Error("Duplicate stage");
+		stages.add(stage.id);
+	}
+	const tasks = /* @__PURE__ */ new Map();
+	if (plan.tasks.length > 200 || plan.stages.length > 50) throw new Error("Plan exceeds 200 tasks or 50 stages");
+	for (const task of plan.tasks) {
+		identifier(task.id);
+		nonempty(task.title, "Task title");
+		if (tasks.has(task.id) || !stages.has(task.stageId)) throw new Error("Duplicate task or missing stage");
+		if (task.kind !== "group" && task.kind !== "task") throw new Error("Invalid task kind");
+		if (task.kind === "task") {
+			if (task.ownerMemberId === void 0 || !memberIds.has(task.ownerMemberId)) throw new Error("Task owner is not in the room");
+			nonempty(task.instruction, "Execution instruction");
+			references(task.criteria, "Acceptance criteria", true);
+		}
+		references(task.inputRefs, "Input references");
+		references(task.artifactPaths, "Planned artifacts");
+		references(task.dependsOn, "Task dependencies");
+		tasks.set(task.id, task);
+	}
+	const edges = /* @__PURE__ */ new Map();
+	for (const task of plan.tasks) {
+		if (task.dependsOn.some((id) => !tasks.has(id))) throw new Error("Missing task dependency");
+		edges.set(task.id, dependenciesOf(plan, task));
+		if (task.parentId !== void 0) {
+			const parent = tasks.get(task.parentId);
+			if (parent?.kind !== "group" || parent.stageId !== task.stageId) throw new Error("Parent must be a group in the same stage");
+		}
+	}
+	for (const task of plan.tasks) if (task.parentId !== void 0) edges.get(task.parentId).push(task.id);
+	const visited = /* @__PURE__ */ new Set();
+	const visiting = /* @__PURE__ */ new Set();
+	const visit = (id) => {
+		if (visiting.has(id)) throw new Error("Task dependency or parent cycle");
+		if (visited.has(id)) return;
+		visiting.add(id);
+		for (const dependency of edges.get(id) ?? []) visit(dependency);
+		visiting.delete(id);
+		visited.add(id);
+	};
+	for (const id of tasks.keys()) visit(id);
+}
+/** Pure transition: the service persists the returned revision before dispatch. */
+function changePlan(current, command, context) {
+	identifier(command.requestId);
+	const signature = planCommandSignature(command);
+	const receipt = current?.requests.find((receipt) => receipt.id === command.requestId);
+	if (receipt !== void 0) {
+		if (receipt.signature !== signature) throw new Error("Plan request identity was reused for different input");
+		return clone(current);
+	}
+	if (context.actor.kind === "worker" && command.action !== "submit") throw new Error("Only the coordinator or human may organize or review a plan");
+	if (command.action === "pause" && command.goalId !== void 0 && command.goalId !== current?.id) throw new Error("Goal changed; read the current plan before pausing");
+	const humanPause = context.actor.kind === "human" && command.action === "pause" && command.goalId === current?.id && current !== void 0;
+	if (command.expectedRevision !== (current?.revision ?? 0) && context.actor.kind !== "worker" && !humanPause) throw new Error("Plan revision changed; read the current plan before retrying");
+	let plan;
+	if (command.action === "create") {
+		if (current !== void 0 && !["completed", "cancelled"].includes(current.status)) throw new Error("An unfinished plan already exists");
+		if (current?.id === command.id) throw new Error("A new goal requires a new identity");
+		identifier(command.id);
+		nonempty(command.objective, "Goal");
+		validateBudget(command.budget);
+		plan = {
+			version: 1,
+			id: command.id,
+			revision: (current?.revision ?? 0) + 1,
+			objective: command.objective,
+			status: command.mode === "execute" ? "running" : "draft",
+			budget: structuredClone(command.budget),
+			activeMs: 0,
+			...command.mode === "execute" ? { resumedAt: context.now } : {},
+			stages: [],
+			tasks: [],
+			requests: []
+		};
+	} else {
+		if (current === void 0) throw new Error("No formal goal exists");
+		plan = clone(current);
+		if (["completed", "cancelled"].includes(plan.status) && command.action !== "reconcile") throw new Error("The plan is closed");
+		switch (command.action) {
+			case "extend":
+				plan.stages.push(...structuredClone(command.stages));
+				for (const task of command.tasks) plan.tasks.push({
+					...structuredClone(task),
+					status: "pending",
+					attempts: []
+				});
+				validateGraph(plan, context.memberIds);
+				for (const task of command.tasks) if (task.parentId !== void 0 && acceptedTask(current, task.parentId)) throw new Error("Cannot extend an accepted group; add a new group");
+				break;
+			case "pause":
+				nonempty(command.reason, "Pause reason");
+				stopClock(plan, context.now);
+				plan.status = "paused";
+				plan.reason = command.reason;
+				break;
+			case "budget":
+				if (context.actor.kind !== "human") throw new Error("Only a human may change the authorized budget");
+				validateBudget(command.budget);
+				plan.budget = structuredClone(command.budget);
+				break;
+			case "resume":
+				if (activePlanAttempts(plan).some((attempt) => attempt.status === "uncertain")) throw new Error("Reconcile uncertain attempts before resuming");
+				if (activePlanMs(plan, context.now) >= plan.budget.maxActiveMs) throw new Error("The active-time budget is exhausted");
+				if (plan.status !== "running") plan.resumedAt = context.now;
+				plan.status = "running";
+				delete plan.reason;
+				break;
+			case "cancel":
+				nonempty(command.reason, "Cancellation reason");
+				stopClock(plan, context.now);
+				plan.status = "cancelled";
+				plan.reason = command.reason;
+				for (const task of plan.tasks) if (task.status === "pending") {
+					task.status = "cancelled";
+					for (const attempt of task.attempts) if (attempt.status === "queued") {
+						attempt.status = "cancelled";
+						attempt.settledAt = context.now;
+					}
+				}
+				break;
+			case "submit": {
+				const [task, attempt] = taskAndAttempt(plan, command.taskId, command.attemptId);
+				if (context.actor.kind === "worker" && task.ownerMemberId !== context.actor.memberId) throw new Error("Workers may only submit their own current attempt");
+				if (attempt.status !== "running") throw new Error("Only the running attempt may submit evidence");
+				evidence(command.evidence);
+				attempt.submission = structuredClone(command.evidence);
+				attempt.status = "submitted";
+				task.status = "submitted";
+				break;
+			}
+			case "review": {
+				const [task, attempt] = taskAndAttempt(plan, command.taskId, command.attemptId);
+				if (attempt.status !== "submitted" || attempt.settledAt === void 0 || attempt.submission === void 0) throw new Error("Review requires a settled submission");
+				nonempty(command.reason, "Review decision");
+				references(command.references, "Review evidence", true);
+				attempt.review = {
+					decision: command.decision,
+					by: context.actor.memberId,
+					reason: command.reason,
+					references: [...command.references],
+					time: context.now
+				};
+				attempt.status = command.decision === "accepted" ? "accepted" : "rejected";
+				task.status = command.decision === "accepted" ? "accepted" : "pending";
+				break;
+			}
+			case "retry": {
+				const task = plan.tasks.find((task) => task.id === command.taskId);
+				if (task?.kind !== "task" || task.status !== "failed") throw new Error("Only a failed task can be retried");
+				nonempty(command.reason, "Retry reason");
+				task.status = "pending";
+				const attempt = latestAttempt(task);
+				if (attempt !== void 0) attempt.retry = {
+					by: context.actor.memberId,
+					reason: command.reason,
+					time: context.now
+				};
+				break;
+			}
+			case "reconcile": {
+				if (context.actor.kind !== "human") throw new Error("Only a human may reconcile an uncertain execution");
+				const [task, attempt] = taskAndAttempt(plan, command.taskId, command.attemptId);
+				if (attempt.status !== "uncertain") throw new Error("Attempt is not uncertain");
+				evidence(command.evidence);
+				attempt.submission = structuredClone(command.evidence);
+				attempt.status = command.outcome;
+				attempt.settledAt = context.now;
+				delete attempt.error;
+				task.status = command.outcome === "submitted" ? "submitted" : "failed";
+				if (plan.reason === "Reconcile uncertain attempts before continuing" && !activePlanAttempts(plan).some((attempt) => attempt.status === "uncertain")) plan.reason = "Interrupted attempts reconciled; review and resume explicitly";
+				break;
+			}
+			case "complete":
+				if (!plan.tasks.some((task) => task.kind === "task" && task.status === "accepted") || plan.tasks.some((task) => task.kind === "task" && !["accepted", "cancelled"].includes(task.status))) throw new Error("All remaining leaf tasks must be accepted before completing the goal");
+				evidence(command.evidence);
+				stopClock(plan, context.now);
+				plan.status = "completed";
+				plan.completion = structuredClone(command.evidence);
+		}
+		plan.revision++;
+	}
+	plan.requests.push({
+		id: command.requestId,
+		signature
+	});
+	return plan;
+}
+/** Reserve a single executable leaf and count the attempt before side effects. */
+function queuePlanAttempt(current, taskId, attemptId, deliveryId, now) {
+	const plan = clone(current);
+	if (!readyPlanTasks(plan).some((task) => task.id === taskId)) throw new Error("Task is not ready for execution");
+	if (activePlanAttempts(plan).length >= plan.budget.maxParallel) throw new Error("Goal concurrency is full");
+	const task = plan.tasks.find((task) => task.id === taskId);
+	if (activePlanMs(plan, now) >= plan.budget.maxActiveMs || task.attempts.length >= plan.budget.maxAttemptsPerTask || plan.tasks.reduce((count, task) => count + task.attempts.length, 0) >= plan.budget.maxAttempts) {
+		stopClock(plan, now);
+		plan.status = "paused";
+		plan.reason = "Execution budget exhausted";
+		plan.revision++;
+		return plan;
+	}
+	identifier(attemptId);
+	nonempty(deliveryId, "Delivery identity");
+	if (plan.tasks.some((task) => task.attempts.some((attempt) => attempt.id === attemptId || attempt.deliveryId === deliveryId))) throw new Error("Attempt or delivery identity already exists");
+	task.attempts.push({
+		id: attemptId,
+		deliveryId,
+		number: task.attempts.length + 1,
+		status: "queued",
+		createdAt: now
+	});
+	task.status = "running";
+	plan.revision++;
+	return plan;
+}
+/** Durable admission; a pause after reservation prevents the native side effect. */
+function admitPlanAttempt(current, taskId, attemptId, now) {
+	const plan = clone(current);
+	if (plan.status !== "running" || activePlanMs(plan, now) >= plan.budget.maxActiveMs) throw new Error("Goal is paused or its active-time budget is exhausted");
+	const [, attempt] = taskAndAttempt(plan, taskId, attemptId);
+	if (attempt.status !== "queued") throw new Error("Attempt is not queued");
+	attempt.status = "running";
+	attempt.startedAt = now;
+	plan.revision++;
+	return plan;
+}
+/** A normal native result is a submission to review, never implicit acceptance. */
+function settlePlanAttempt(current, taskId, attemptId, result, now) {
+	const plan = clone(current);
+	const task = plan.tasks.find((task) => task.id === taskId);
+	const attempt = task?.attempts.at(-1);
+	if (task === void 0 || attempt?.id !== attemptId || attempt.settledAt !== void 0 || attempt.status === "uncertain") return plan;
+	if (attempt.startedAt === void 0 && current.status === "paused") {
+		attempt.status = "cancelled";
+		attempt.error = "Paused before native admission";
+		attempt.settledAt = now;
+		task.status = "pending";
+		plan.revision++;
+		return plan;
+	}
+	if (result.state === "done") {
+		if (result.evidence !== void 0 && attempt.submission === void 0) {
+			evidence(result.evidence);
+			attempt.submission = structuredClone(result.evidence);
+		}
+		if (attempt.submission === void 0) {
+			attempt.status = "failed";
+			task.status = "failed";
+			attempt.error = "Execution finished without submission evidence";
+		} else {
+			attempt.status = "submitted";
+			task.status = "submitted";
+		}
+	} else {
+		attempt.status = result.state;
+		task.status = result.state === "cancelled" ? "cancelled" : "failed";
+		if (result.error !== void 0) attempt.error = result.error;
+	}
+	attempt.settledAt = now;
+	plan.revision++;
+	return plan;
+}
+/** Restart always pauses automation and fences native executions with unknown outcomes. */
+function recoverPlan(current, now) {
+	const plan = clone(current);
+	if (plan.status === "completed") return plan;
+	if (plan.status === "running") {
+		stopClock(plan, now);
+		plan.status = "paused";
+		plan.reason = "Host restarted; review and resume explicitly";
+	}
+	for (const task of plan.tasks) {
+		const attempt = latestAttempt(task);
+		if (attempt !== void 0 && attempt.settledAt === void 0 && ["running", "submitted"].includes(attempt.status)) {
+			attempt.status = "uncertain";
+			attempt.error = "Execution outcome is unknown after restart";
+			task.status = "failed";
+			if (plan.status !== "cancelled") plan.status = "paused";
+			plan.reason = "Reconcile uncertain attempts before continuing";
+		}
+	}
+	plan.revision++;
+	return plan;
+}
+const shortText = {
+	type: "string",
+	minLength: 1,
+	maxLength: 32e3
+};
+const idSchema = {
+	type: "string",
+	pattern: "^[a-zA-Z0-9][a-zA-Z0-9_.:-]{0,127}$"
+};
+const strings = {
+	type: "array",
+	items: shortText,
+	maxItems: 100
+};
+const object = (properties, optional = []) => ({
+	type: "object",
+	properties,
+	required: Object.keys(properties).filter((key) => !optional.includes(key)),
+	additionalProperties: false
+});
+const enumeration = (...values) => ({
+	type: "string",
+	enum: values
+});
+const integer = (minimum, maximum) => ({
+	type: "integer",
+	minimum,
+	maximum
+});
+const evidenceSchema = object({
+	summary: shortText,
+	references: {
+		...strings,
+		minItems: 1
+	},
+	artifacts: strings
+});
+const budgetSchema = object({
+	maxParallel: integer(1, 8),
+	maxAttempts: integer(1, 100),
+	maxAttemptsPerTask: integer(1, 10),
+	maxActiveMs: integer(1, 864e5)
+});
+const taskSchema = object({
+	id: idSchema,
+	title: shortText,
+	stageId: idSchema,
+	parentId: idSchema,
+	kind: enumeration("task", "group"),
+	ownerMemberId: idSchema,
+	instruction: {
+		type: "string",
+		maxLength: 32e3
+	},
+	criteria: strings,
+	inputRefs: strings,
+	artifactPaths: strings,
+	dependsOn: {
+		type: "array",
+		items: idSchema,
+		maxItems: 100
+	}
+}, ["parentId", "ownerMemberId"]);
+const base = {
+	requestId: idSchema,
+	expectedRevision: integer(0, Number.MAX_SAFE_INTEGER)
+};
+const commandSchema = { oneOf: [
+	object({
+		...base,
+		action: enumeration("create"),
+		id: idSchema,
+		objective: shortText,
+		mode: enumeration("draft", "execute"),
+		budget: budgetSchema
+	}),
+	object({
+		...base,
+		action: enumeration("extend"),
+		stages: {
+			type: "array",
+			items: object({
+				id: idSchema,
+				title: shortText
+			}),
+			maxItems: 50
+		},
+		tasks: {
+			type: "array",
+			items: taskSchema,
+			maxItems: 200
+		}
+	}),
+	object({
+		...base,
+		action: enumeration("pause"),
+		reason: shortText,
+		goalId: idSchema
+	}, ["goalId"]),
+	object({
+		...base,
+		action: enumeration("resume")
+	}),
+	object({
+		...base,
+		action: enumeration("budget"),
+		budget: budgetSchema
+	}),
+	object({
+		...base,
+		action: enumeration("cancel"),
+		reason: shortText
+	}),
+	object({
+		...base,
+		action: enumeration("submit"),
+		taskId: idSchema,
+		attemptId: idSchema,
+		evidence: evidenceSchema
+	}),
+	object({
+		...base,
+		action: enumeration("review"),
+		taskId: idSchema,
+		attemptId: idSchema,
+		decision: enumeration("accepted", "rework"),
+		reason: shortText,
+		references: {
+			...strings,
+			minItems: 1
+		}
+	}),
+	object({
+		...base,
+		action: enumeration("retry"),
+		taskId: idSchema,
+		reason: shortText
+	}),
+	object({
+		...base,
+		action: enumeration("reconcile"),
+		taskId: idSchema,
+		attemptId: idSchema,
+		outcome: enumeration("failed", "submitted"),
+		evidence: evidenceSchema
+	}),
+	object({
+		...base,
+		action: enumeration("complete"),
+		evidence: evidenceSchema
+	})
+] };
+/** Validate only the small JSON-schema vocabulary used by the published contract. */
+function validateWire(value, schema, path) {
+	const fail = () => {
+		throw new Error(`Invalid plan command at ${path}`);
+	};
+	if (schema.oneOf !== void 0) {
+		for (const alternative of schema.oneOf) try {
+			validateWire(value, alternative, path);
+			return;
+		} catch {}
+		fail();
+	}
+	if (schema.type === "string") {
+		if (typeof value !== "string") fail();
+		const text = value;
+		if (schema.minLength !== void 0 && text.length < schema.minLength || schema.maxLength !== void 0 && text.length > schema.maxLength || schema.enum !== void 0 && !schema.enum.includes(text) || schema.pattern !== void 0 && !new RegExp(schema.pattern).test(text)) fail();
+	} else if (schema.type === "integer") {
+		if (typeof value !== "number" || !Number.isSafeInteger(value) || value < schema.minimum || value > schema.maximum) fail();
+	} else if (schema.type === "array") {
+		if (!Array.isArray(value)) fail();
+		const items = value;
+		if (items.length < (schema.minItems ?? 0) || items.length > (schema.maxItems ?? Infinity)) fail();
+		for (const [index, item] of items.entries()) validateWire(item, schema.items, `${path}[${index}]`);
+	} else if (schema.type === "object") {
+		if (value === null || typeof value !== "object" || Array.isArray(value)) fail();
+		const record = value;
+		if (schema.required?.some((key) => !Object.hasOwn(record, key)) || Object.keys(record).some((key) => !Object.hasOwn(schema.properties, key))) fail();
+		for (const [key, item] of Object.entries(record)) validateWire(item, schema.properties[key], `${path}.${key}`);
+	}
+}
+/** One bounded, strict wire grammar is shared by native tools, MCP and the UI. */
+function parsePlanCommand(text) {
+	if (typeof text !== "string" || text.length > 131072) throw new Error("Plan command exceeds 128 KiB");
+	const value = JSON.parse(text);
+	validateWire(value, commandSchema, "command");
+	return value;
+}
+/** JSON schema supplied through room_read so both harness families see one contract. */
+function planCommandContract() {
+	return structuredClone(commandSchema);
+}
+/** Object field order is not part of a retry identity; array order remains meaningful. */
+function planCommandSignature(command) {
+	const stable = (value) => Array.isArray(value) ? value.map(stable) : value !== null && typeof value === "object" ? Object.fromEntries(Object.entries(value).sort(([a], [b]) => a.localeCompare(b)).map(([key, item]) => [key, stable(item)])) : value;
+	return JSON.stringify(stable(command));
+}
+//#endregion
+//#region lib/types/plan-service.js
+function readPlan(room) {
+	const event = room.snapshotEvents().filter((event) => event.type === "room/plan-state").at(-1);
+	return event?.type === "room/plan-state" ? structuredClone(event.data) : void 0;
+}
+/** One serialized writer for durable goal transitions and automatic leaf dispatch. */
+var PlanService = class {
+	ctx;
+	engine;
+	tails = /* @__PURE__ */ new Map();
+	recovered = /* @__PURE__ */ new Set();
+	timers = /* @__PURE__ */ new Map();
+	constructor(ctx, engine) {
+		this.ctx = ctx;
+		this.engine = engine;
+	}
+	locked(room, action) {
+		const next = (this.tails.get(room.id) ?? Promise.resolve()).catch(() => {}).then(action);
+		this.tails.set(room.id, next);
+		next.finally(() => {
+			if (this.tails.get(room.id) === next) this.tails.delete(room.id);
+		}).catch(() => {});
+		return next;
+	}
+	/** Cold inspection projects the restart pause without writing or starting agents. */
+	view(sessionId, view) {
+		if (this.recovered.has(sessionId)) return view;
+		const { requests: _requests, ...recovered } = recoverPlan({
+			...view,
+			requests: []
+		}, Date.now());
+		return recovered;
+	}
+	async recover(room) {
+		return this.locked(room, () => this.recoverUnlocked(room));
+	}
+	async recoverUnlocked(room) {
+		if (this.recovered.has(room.id)) return;
+		const current = readPlan(room);
+		if (current !== void 0) {
+			const recovered = recoverPlan(current, Date.now());
+			const events = room.snapshotEvents();
+			for (const task of recovered.tasks) {
+				const attempt = task.attempts.at(-1);
+				if (attempt?.status !== "queued") continue;
+				const dispatch = events.find((event) => event.type === "room/dispatch" && event.data.id === attempt.deliveryId);
+				if (dispatch?.type !== "room/dispatch") continue;
+				const edge = events.filter((event) => event.type === "room/delivery-state" && event.data.dispatchSeq === dispatch.seq).at(-1);
+				if (edge?.type === "room/delivery-state" && ["running", "uncertain"].includes(edge.data.state)) {
+					attempt.status = "uncertain";
+					attempt.error = "Restart interrupted the durable admission boundary";
+					task.status = "failed";
+					recovered.status = "paused";
+					recovered.reason = "Reconcile uncertain attempts before continuing";
+				}
+			}
+			room.append("room/plan-state", recovered);
+			await this.ctx.sessions.flush(room);
+		}
+		this.recovered.add(room.id);
+	}
+	async write(room, plan) {
+		room.append("room/plan-state", plan);
+		await this.ctx.sessions.flush(room);
+		this.armDeadline(room, plan);
+	}
+	armDeadline(room, plan) {
+		clearTimeout(this.timers.get(room.id));
+		this.timers.delete(room.id);
+		if (plan.status !== "running") return;
+		const remaining = Math.max(1, plan.budget.maxActiveMs - activePlanMs(plan, Date.now()));
+		const timer = setTimeout(() => {
+			this.locked(room, async () => {
+				const current = readPlan(room);
+				if (current?.status !== "running") return;
+				if (activePlanMs(current, Date.now()) < current.budget.maxActiveMs) {
+					this.armDeadline(room, current);
+					return;
+				}
+				const paused = changePlan(current, {
+					action: "pause",
+					reason: "Active-time budget exhausted",
+					requestId: randomUUID(),
+					expectedRevision: current.revision
+				}, {
+					actor: {
+						kind: "coordinator",
+						memberId: "budget-timer"
+					},
+					memberIds: /* @__PURE__ */ new Set(),
+					now: Date.now()
+				});
+				await this.write(room, paused);
+			}).catch((error) => this.ctx.logger.warn(`room: goal deadline persistence failed: ${String(error)}`));
+		}, Math.min(remaining, 2147483647));
+		timer.unref?.();
+		this.timers.set(room.id, timer);
+	}
+	async command(room, json, actor) {
+		const command = parsePlanCommand(json);
+		return this.locked(room, async () => {
+			await this.recoverUnlocked(room);
+			const events = room.snapshotEvents();
+			const state = replay(events);
+			const members = new Set(state.members.map((member) => memberId(events, member)));
+			if (actor.kind !== "human" && !members.has(actor.memberId)) throw new Error("Calling member left the room");
+			const coordinator = coordinatorMember(state, events);
+			if (actor.kind === "coordinator" && (coordinator === void 0 || memberId(events, coordinator) !== actor.memberId)) throw new Error("Coordinator changed before command admission");
+			const earlier = events.filter((event) => event.type === "room/plan-state").flatMap((event) => event.type === "room/plan-state" ? event.data.requests : []).find((receipt) => receipt.id === command.requestId);
+			if (earlier !== void 0) {
+				if (earlier.signature !== planCommandSignature(command)) throw new Error("Plan request identity was reused for different input");
+				await this.ctx.sessions.flush(room);
+				await this.pump(room);
+				await this.engine().recover(room);
+				return readPlan(room);
+			}
+			const current = readPlan(room);
+			const next = changePlan(current, command, {
+				actor,
+				memberIds: members,
+				now: Date.now()
+			});
+			const wake = actor.kind === "human" && coordinator !== void 0 && next.status === "running" && (command.action === "create" && command.mode === "execute" || command.action === "resume" && (current?.status === "draft" || next.tasks.length === 0)) ? room.append("room/dispatch", {
+				id: randomUUID(),
+				origin: "report",
+				reportFor: `goal-start:${next.id}:${command.requestId}`,
+				targets: [coordinator.name],
+				targetIds: [memberId(events, coordinator)],
+				plan: { goalId: next.id },
+				text: `The human authorized execution of goal ${next.id}: ${next.objective}. Read room_read, organize appropriate stages and tasks with room_plan, invite members when useful, and dispatch within the recorded budget. Small work can remain direct. Review submitted evidence before accepting tasks; wait for correlated reports instead of polling.`
+			}) : void 0;
+			if (command.action === "reconcile") this.reconcileDelivery(room, next, command.taskId, command.attemptId, command.requestId);
+			await this.write(room, next);
+			await this.pump(room);
+			if (wake !== void 0 && coordinator !== void 0) this.engine().dispatch(room, coordinator.name, wake.data.text, {
+				dispatchSeq: wake.seq,
+				targetId: memberId(events, coordinator)
+			});
+			if (command.action === "resume" || command.action === "cancel" || command.action === "complete") await this.engine().recover(room);
+			return readPlan(room);
+		});
+	}
+	allows(room, dispatchSeq) {
+		if (dispatchSeq === void 0) return true;
+		const event = room.snapshotEvents().find((event) => event.seq === dispatchSeq);
+		if (event?.type !== "room/dispatch" || event.data.plan === void 0) return true;
+		const plan = readPlan(room);
+		return this.recovered.has(room.id) && plan?.id === event.data.plan.goalId && plan.status === "running";
+	}
+	async admitted(room, dispatchSeq) {
+		if (dispatchSeq === void 0) return;
+		const event = room.snapshotEvents().find((event) => event.seq === dispatchSeq);
+		if (event?.type !== "room/dispatch" || event.data.plan === void 0) return;
+		const link = event.data.plan;
+		await this.locked(room, async () => {
+			await this.recoverUnlocked(room);
+			const plan = readPlan(room);
+			if (plan?.id !== link.goalId || plan.status !== "running") throw new Error("Goal no longer permits automatic work");
+			if (link.taskId !== void 0 && link.attemptId !== void 0) await this.write(room, admitPlanAttempt(plan, link.taskId, link.attemptId, Date.now()));
+		});
+	}
+	async settled(room, dispatchSeq, outcome) {
+		if (dispatchSeq === void 0) return;
+		const event = room.snapshotEvents().find((event) => event.seq === dispatchSeq);
+		if (event?.type !== "room/dispatch" || event.data.plan?.taskId === void 0 || event.data.plan.attemptId === void 0) return;
+		const { goalId, taskId, attemptId } = event.data.plan;
+		await this.locked(room, async () => {
+			const current = readPlan(room);
+			if (current?.id !== goalId) return;
+			const next = settlePlanAttempt(current, taskId, attemptId, {
+				state: outcome.state,
+				...outcome.error === void 0 ? {} : { error: outcome.error },
+				...outcome.state === "done" && outcome.text?.trim() ? { evidence: {
+					summary: outcome.text.slice(0, 32e3),
+					references: [`room-delivery:${room.id}:${dispatchSeq}`],
+					artifacts: []
+				} } : {}
+			}, Date.now());
+			await this.write(room, next);
+			await this.pump(room);
+		});
+	}
+	/** Human goal reconciliation settles its room delivery and supersedes stale queued reports. */
+	reconcileDelivery(room, plan, taskId, attemptId, requestId) {
+		const attempt = plan.tasks.find((task) => task.id === taskId)?.attempts.find((attempt) => attempt.id === attemptId);
+		if (attempt === void 0) return;
+		const events = room.snapshotEvents();
+		const dispatch = events.find((event) => event.type === "room/dispatch" && event.data.id === attempt.deliveryId);
+		if (dispatch?.type !== "room/dispatch") return;
+		const state = replay(events);
+		for (const target of dispatch.data.targetIds ?? []) {
+			const deliveryId = `${dispatch.seq}:${target}`;
+			const member = state.members.find((member) => memberId(events, member) === target);
+			const run = state.runs.find((run) => run.member === member?.name);
+			if (run?.runId === deliveryId && ["running", "failed"].includes(run.state)) room.append("room/run-state", {
+				member: run.member,
+				runId: run.runId,
+				startedAt: run.startedAt,
+				state: attempt.status === "submitted" ? "done" : "failed",
+				...attempt.status === "failed" ? { error: attempt.submission?.summary ?? "Human reconciled the attempt as failed" } : {}
+			});
+			room.append("room/delivery-state", {
+				id: deliveryId,
+				dispatchSeq: dispatch.seq,
+				memberId: target,
+				state: attempt.status === "submitted" ? "done" : "failed",
+				text: attempt.submission?.summary ?? "Human reconciliation"
+			});
+			for (const oldReport of events) {
+				if (oldReport.type !== "room/dispatch" || oldReport.data.reportFor !== deliveryId) continue;
+				for (const recipient of oldReport.data.targetIds ?? []) {
+					const oldId = `${oldReport.seq}:${recipient}`;
+					if (state.deliveries?.find((delivery) => delivery.id === oldId)?.status === "queued") room.append("room/delivery-state", {
+						id: oldId,
+						dispatchSeq: oldReport.seq,
+						memberId: recipient,
+						state: "cancelled",
+						error: "Superseded by human reconciliation"
+					});
+				}
+			}
+		}
+		const coordinator = coordinatorMember(state, events);
+		if (coordinator !== void 0) room.append("room/dispatch", {
+			id: randomUUID(),
+			origin: "report",
+			reportFor: `reconcile:${attempt.id}:${requestId}`,
+			targets: [coordinator.name],
+			targetIds: [memberId(events, coordinator)],
+			plan: { goalId: plan.id },
+			text: `Human reconciled task ${taskId}, attempt ${attemptId} as ${attempt.status}. Evidence: ${JSON.stringify(attempt.submission)}. Read the current plan before reviewing or retrying.`
+		});
+	}
+	async pump(room) {
+		let plan = readPlan(room);
+		if (plan?.status !== "running") return;
+		for (const task of readyPlanTasks(plan)) {
+			const events = room.snapshotEvents();
+			const state = replay(events);
+			const owner = state.members.find((member) => memberId(events, member) === task.ownerMemberId);
+			const coordinator = coordinatorMember(state, events);
+			if (owner === void 0 || coordinator === void 0) {
+				await this.write(room, changePlan(plan, {
+					action: "pause",
+					reason: "A task owner or coordinator is unavailable",
+					requestId: randomUUID(),
+					expectedRevision: plan.revision
+				}, {
+					actor: {
+						kind: "coordinator",
+						memberId: "scheduler"
+					},
+					memberIds: /* @__PURE__ */ new Set(),
+					now: Date.now()
+				}));
+				return;
+			}
+			const attemptId = randomUUID();
+			const dispatchId = randomUUID();
+			let reserved;
+			try {
+				reserved = queuePlanAttempt(plan, task.id, attemptId, dispatchId, Date.now());
+			} catch (error) {
+				if (String(error).includes("concurrency is full")) return;
+				throw error;
+			}
+			if (reserved.status !== "running") {
+				await this.write(room, reserved);
+				return;
+			}
+			const dependencyEvidence = dependencyResults(plan, task);
+			const text = [
+				`Goal ${plan.id}, task ${task.id}, attempt ${attemptId}.`,
+				`Objective: ${plan.objective}`,
+				task.instruction,
+				`Acceptance criteria: ${JSON.stringify(task.criteria)}`,
+				`Inputs: ${JSON.stringify(task.inputRefs)}. Expected artifacts: ${JSON.stringify(task.artifactPaths)}.`,
+				`Accepted dependency results: ${JSON.stringify(dependencyEvidence)}`,
+				"Submit your result and evidence with room_plan action submit (taskId, attemptId, evidence: {summary,references,artifacts}, requestId, expectedRevision from room_read). Only the coordinator or human accepts results; do not claim acceptance yourself."
+			].join("\n");
+			const dispatch = room.append("room/dispatch", {
+				id: dispatchId,
+				origin: "coordinator",
+				targets: [owner.name],
+				targetIds: [task.ownerMemberId],
+				text,
+				plan: {
+					goalId: plan.id,
+					taskId: task.id,
+					attemptId
+				},
+				...memberId(events, coordinator) === task.ownerMemberId ? {} : { replyTo: memberId(events, coordinator) }
+			});
+			await this.write(room, reserved);
+			this.engine().dispatch(room, owner.name, text, {
+				dispatchSeq: dispatch.seq,
+				targetId: task.ownerMemberId
+			});
+			plan = reserved;
+		}
+	}
+	dispose() {
+		for (const timer of this.timers.values()) clearTimeout(timer);
+		this.timers.clear();
+	}
+};
+//#endregion
+//#region lib/types/agent-setup.js
+/**
+* Which preset a session actually runs, newest selection winning. The 0.1.2
+* host folds the header plus `agent-preset/selected` events through
+* `agentPresetProjectionDefinition`; the rc host's `resolveSessionPreset` is
+* the same fold. A host with neither yields undefined: the resume falls back
+* to the deployment's default preset, the same outcome a preset-less session
+* had before.
+* @param host - the agent-presets module namespace, structurally probed.
+* @param session - the session's header and event log.
+* @returns the preset id, or `undefined` when the session names none.
+*/
+function deriveSessionPreset(host, session) {
+	if (host.agentPresetProjectionDefinition !== void 0) {
+		const projection = host.agentPresetProjectionDefinition;
+		let state = projection.init(session.header);
+		for (const event of session.events) state = projection.apply(state, event);
+		return state ?? void 0;
+	}
+	return host.resolveSessionPreset?.(session);
+}
+let presetRegistryProbe;
+let probedHost = {};
+/**
+* Resolve the preset-registry module by name. The 0.1.7-rc.1 host renamed
+* `@deepseek-ai/dsh-agent-presets` to `@deepseek-ai/dsh-agent-preset-registry`
+* (the API carried over); 0.1.5/0.1.6 hosts install only the old name, and a
+* host without preset composition installs neither — `null`, and the
+* derivation host stays `{}`, the established no-preset degrade (the resume
+* falls back to the deployment's default preset). A STATIC import of either
+* name is a module-resolution failure at load on hosts installing only the
+* other — pack-dist strips `dependencies`, so the specifier resolves against
+* the host's install tree. Both specifiers stay static string literals so
+* tsdown externalizes them and tsc type-checks them.
+* @returns the module namespace, or null when neither name resolves.
+*/
+function loadPresetRegistry() {
+	presetRegistryProbe ??= import("@deepseek-ai/dsh-agent-preset-registry").catch(() => import("@deepseek-ai/dsh-agent-presets")).catch(() => null);
+	return presetRegistryProbe;
+}
+/**
+* The derivation input resolved by the last preload. `{}` before it, which
+* the derivation reads as "no preset surface" — the no-preset degrade.
+*/
+function presetDerivationHost() {
+	return probedHost;
+}
+/**
+* Populate {@link presetDerivationHost} once, at apply time — every
+* derivation happens on the resume/create paths that run after apply.
+*/
+async function preloadPresetDerivationHost() {
+	probedHost = await loadPresetRegistry() ?? {};
+}
+/**
+* Probe the agent-presets roster.
+* @param ctx - host context.
+* @returns the roster slice, or undefined when the composition mounts none
+* (the agent then composes plain — the pre-presets host behavior).
+*/
+function probeAgentPresets(ctx) {
+	const service = ctx.get("agentPresets");
+	if (service === void 0 || service === null) return void 0;
+	return typeof service.resolve === "function" && typeof service.mount === "function" ? service : void 0;
+}
+/**
+* Compose the create/resume setup for a room session's agent, mirroring the
+* official web path: resolve first (creation records the id on the header),
+* then mount into the agent's scope during setup.
+* @param ctx - host context.
+* @param presetId - the preset to compose; undefined resolves the default.
+* @returns the composition (empty when no presets roster is mounted).
+*/
+async function composeRoomAgent(ctx, presetId) {
+	const presets = probeAgentPresets(ctx);
+	if (presets === void 0) return {};
+	const resolved = await presets.resolve(presetId);
+	return {
+		agentPreset: resolved.id,
+		setup: async (agentCtx) => {
+			await presets.mount(agentCtx, resolved.id);
+		}
+	};
+}
+/**
+* The preset a room session runs, read from its log (a blank-window switch
+* wins over the creation header — the official reconstruction rule).
+* @param session - the live room session.
+* @returns the preset id, or undefined when none was recorded.
+*/
+function roomSessionPreset(session) {
+	return deriveSessionPreset(presetDerivationHost(), {
+		header: session.header,
+		events: session.snapshotEvents()
+	});
+}
+/**
+* Probe the session-persistence service.
+* @param ctx - host context.
+* @returns the handle-opening slice, or undefined when no backend is mounted.
+*/
+function probeSessionPersistence(ctx) {
+	const service = ctx.get("sessionPersistence");
+	if (service === void 0 || service === null) return void 0;
+	return typeof service.open === "function" ? service : void 0;
+}
+/**
+* Read a cold session's log from persistence without attaching or resuming
+* anything (the read-only remotes' cold path). The 0.1.5 handle-based API
+* replaced the one-shot `inspect`: open a read handle (no write ownership),
+* read the full log, close.
+* @param ctx - host context.
+* @param sessionId - the persisted session.
+* @returns the inspection, or undefined when absent/unreadable.
+*/
+async function inspectCold(ctx, sessionId) {
+	const persistence = probeSessionPersistence(ctx);
+	if (persistence === void 0) return void 0;
+	try {
+		const handle = await persistence.open(sessionId, "read");
+		try {
+			const cold = await handle.read(0);
+			return {
+				meta: structuredClone(handle.header),
+				inheritedEventCount: handle.inheritedEventCount,
+				events: [...cold.events]
+			};
+		} finally {
+			await handle.close();
+		}
+	} catch {
+		return;
+	}
+}
+//#endregion
+//#region lib/types/adapter.js
+/** The methods a service must carry to quack like the facade. */
+const FACADE_METHODS = [
+	"start",
+	"resume",
+	"cancel"
+];
+/**
+* Probe the local-agent facade.
+* @param ctx - host context.
+* @returns the facade when `localAgent` is present and carries the full M1
+* method set, undefined otherwise (absent core, or a pre-facade version).
+*/
+function probeLocalAgent(ctx) {
+	const service = ctx.get("localAgent");
+	if (service === void 0 || service === null) return void 0;
+	return FACADE_METHODS.every((method) => typeof service[method] === "function") ? service : void 0;
+}
+/**
+* Probe the registry's roster slice (independent of the delegation facade:
+* a core without M1 still serves the roster, and the invite dialog greys
+* undispatchable providers instead of hiding them).
+* @param ctx - host context.
+* @returns the roster slice, or undefined.
+*/
+function probeLocalAgentRoster(ctx) {
+	const service = ctx.get("localAgent");
+	if (service === void 0 || service === null) return void 0;
+	return typeof service["roster"] === "function" && typeof service["statusOf"] === "function" ? service : void 0;
+}
+/**
+* Extract a member's reply text from a settled run: the text blocks of its
+* final output, joined. Non-text blocks (images etc.) are dropped — the
+* blackboard is a text layer.
+* @param output - the settled run's output content.
+* @returns the reply text (empty string when the run produced no text).
+*/
+function runOutputText(output) {
+	return output.flatMap((block) => block.type === "text" ? [block.text] : []).join("\n");
+}
+/** The producer-owned source kind identifying every room-dispatch followup. */
+const ROOM_KIND = "room";
+/** The producer-owned source of a room main-agent followup. */
+function roomSource() {
+	return Object.freeze({ kind: ROOM_KIND });
+}
+/**
+* Whether a durable source belongs to the room producer, in every form the
+* log can hold: the current producer-owned kind (`room`), the V3→V4 migrated
+* kind (`plugin:@khorsheed/dsh-room`), and the released V3 wrapper a pre-V4
+* (0.1.5) host still serves verbatim.
+* @param source - the persisted message source to test.
+* @returns true when the source names this producer.
+*/
+function isRoomSource(source) {
+	if (typeof source !== "object" || source === null) return false;
+	const record = source;
+	return record.kind === "room" || record.kind === `plugin:@khorsheed/dsh-room` || record.kind === "plugin" && record.plugin === "@khorsheed/dsh-room";
+}
+function closedGoal(state, goalId) {
+	return goalId !== void 0 && state.plan !== void 0 && (state.plan.id !== goalId || ["completed", "cancelled"].includes(state.plan.status));
+}
+/**
+* The roster section: one line per OTHER member (name, provider, one-line
+* role) plus the notification protocol — the fallback channel's trailing
+* own-line `@name <content>` format lives here so a member can reach others
+* without any bridge tooling. Carried only when the member has never seen
+* the roster or it changed since their last dispatch ({@link rosterStaleSince});
+* the member's own session holds it in between. The room GOAL is NOT part of
+* this section: it rides every dispatch on its own line (cheap, and it
+* orients the task).
+*/
+function rosterSection(state, self) {
+	return [
+		"【成员名册】",
+		...state.members.filter((member) => member.name !== self).map((member) => {
+			const provider = member.kind === "main-agent" ? "原生 DSH" : member.provider ?? "";
+			const role = member.instructions?.split("\n", 1)[0]?.trim();
+			return `- ${member.name}（${provider}）${role === void 0 || role === "" ? "" : `：${role}`}`;
+		}),
+		"通知协议：要通知某个成员，在回复末尾独占一行写 `@名字 <内容>`；该行会被转交给对方（一阶段需房间主人确认）。"
+	].join("\n");
+}
+/** The notifications section: confirmed-undelivered relays addressed to the member. */
+function notificationsSection(relays) {
+	return ["【通知】", ...relays.map((relay) => `- ${relay.from} 给你的通知: ${relay.content}`)].join("\n");
+}
+/**
+* Assemble the uniform member prompt: role-instructions carry, then the room
+* goal (every dispatch), then the roster (only when stale for this member),
+* then the member's confirmed-undelivered notifications (except the ones
+* this dispatch's own text already delivers), then this dispatch's text.
+*/
+function assemblePrompt(room, member, cursor, text, relayIds) {
+	const state = replay(room.snapshotEvents());
+	const carried = state.relays.filter((relay) => relay.state === "confirmed" && relay.to === member.name && !relayIds.includes(relay.id));
+	const sections = [];
+	const handoff = room.snapshotEvents().filter((event) => event.type === "room/coordinator" && event.data.memberId === memberId(room.snapshotEvents(), member)).at(-1);
+	if (handoff?.type === "room/coordinator" && (cursor === void 0 || handoff.seq > cursor)) sections.push(handoff.data.handoff);
+	if (coordinatorMember(state, room.snapshotEvents())?.name === member.name) sections.push("You are the room coordinator. Handle ordinary chat directly; delegate small work in the background using room tools. Establish a goal plan only when useful for the requested execution. Delegate results arrive as correlated reports; do not poll while waiting.");
+	const pending = pendingInstructions(room.snapshotEvents(), member.name, cursor);
+	if (pending?.kind === "initial") sections.push(`你的角色指令：${pending.instructions}`);
+	if (pending?.kind === "update") sections.push(`你的角色指令更新为：${pending.instructions}`);
+	if (state.goal !== void 0) sections.push(`本房间的目标：${state.goal}`);
+	if (rosterStaleSince(room.snapshotEvents(), cursor)) sections.push(rosterSection(state, member.name));
+	if (carried.length > 0) sections.push(notificationsSection(carried));
+	sections.push(text);
+	return {
+		prompt: sections.join("\n\n"),
+		carried
+	};
+}
+/** The human-readable reason a run failed (Error message, else String()). */
+function faultMessage(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+/**
+* The per-room dispatch engine. Owned by the RoomService; all state lives in
+* the journal except the in-process FIFO queues (a restart simply has no
+* in-flight runs).
+*/
+var DispatchEngine = class {
+	ctx;
+	hooks;
+	/** memberKey → the queue tail promise. */
+	queues = /* @__PURE__ */ new Map();
+	scheduled = /* @__PURE__ */ new Set();
+	inFlight = /* @__PURE__ */ new Map();
+	/**
+	* @param ctx - host context carrying the session store and agents registry.
+	*/
+	constructor(ctx, hooks = {}) {
+		this.ctx = ctx;
+		this.hooks = hooks;
+	}
+	/**
+	* Enqueue a dispatch for execution. Fire-and-forget: the outcome is
+	* journaled as run-state/speech events, never returned to the caller.
+	* @param room - the room session.
+	* @param memberName - the dispatch target.
+	* @param text - the dispatch text.
+	* @param options - dispatch-event seq and/or the relays this run delivers.
+	*/
+	hasPending(room, memberName) {
+		const member = replay(room.snapshotEvents()).members.find((member) => member.name === memberName);
+		return member !== void 0 && ([...this.inFlight.values()].includes(`${room.id} ${memberId(room.snapshotEvents(), member)}`) || replayDeliveries(room.snapshotEvents()).some((delivery) => delivery.memberId === member.id && [
+			"queued",
+			"running",
+			"uncertain"
+		].includes(delivery.status)));
+	}
+	dispatch(room, memberName, text, options = {}) {
+		const events = room.snapshotEvents();
+		const member = replay(events).members.find((entry) => entry.name === memberName);
+		if (member === void 0) return;
+		const targetId = options.targetId ?? memberId(events, member);
+		const key = `${room.id} ${targetId}`;
+		const deliveryId = options.dispatchSeq === void 0 ? void 0 : `${options.dispatchSeq}:${targetId}`;
+		if (deliveryId !== void 0) {
+			const scopedId = `${room.id}:${deliveryId}`;
+			if (this.scheduled.has(scopedId) || events.some((event) => event.type === "room/delivery-state" && event.data.id === deliveryId)) return;
+			this.scheduled.add(scopedId);
+		}
+		const tail = this.queues.get(key) ?? Promise.resolve();
+		let submitted;
+		const submission = new Promise((resolve) => {
+			submitted = resolve;
+		});
+		const next = tail.then(() => this.run(room, memberName, text, {
+			...options,
+			targetId
+		}, submitted)).catch((error) => {
+			this.ctx.logger.warn(`room: dispatch to "${memberName}" faulted: ${String(error)}`);
+		}).finally(() => {
+			submitted();
+			this.inFlight.delete(next);
+			if (deliveryId !== void 0) this.scheduled.delete(`${room.id}:${deliveryId}`);
+		});
+		this.inFlight.set(next, key);
+		this.queues.set(key, submission);
+		submission.then(() => {
+			if (this.queues.get(key) === submission) this.queues.delete(key);
+		});
+	}
+	/** Drain includes reports queued by the runs being drained. */
+	async idle() {
+		while (this.inFlight.size > 0) await Promise.all([...this.inFlight.keys()]);
+	}
+	/** Read-only recovery projection: persisted running edges are not live processes. */
+	view(sessionId, state) {
+		const error = "Execution outcome is unknown after restart; reconcile before retrying";
+		return {
+			...state,
+			...state.deliveries === void 0 ? {} : { deliveries: state.deliveries.map((row) => row.status === "queued" && closedGoal(state, row.plan?.goalId) ? {
+				...row,
+				status: "cancelled"
+			} : row.status === "running" && !this.scheduled.has(`${sessionId}:${row.id}`) ? {
+				...row,
+				status: "uncertain",
+				error
+			} : row) },
+			runs: state.runs.map((run) => {
+				const member = state.members.find((row) => row.name === run.member);
+				const active = run.runId === void 0 ? member !== void 0 && [...this.inFlight.values()].includes(`${sessionId} ${member.id}`) : this.scheduled.has(`${sessionId}:${run.runId}`);
+				return run.state === "running" && !active ? {
+					...run,
+					state: "failed",
+					error
+				} : run;
+			})
+		};
+	}
+	/** Restore accepted targets, never repeat an execution whose settlement is unknown. */
+	async recover(room) {
+		const events = room.snapshotEvents();
+		const state = replay(events);
+		for (const dispatch of events) {
+			if (dispatch.type !== "room/dispatch" || dispatch.data.targetIds === void 0) continue;
+			for (const targetId of dispatch.data.targetIds) {
+				const id = `${dispatch.seq}:${targetId}`;
+				if (this.scheduled.has(`${room.id}:${id}`)) continue;
+				const last = events.filter((event) => event.type === "room/delivery-state" && event.data.id === id).at(-1);
+				if (last === void 0 && closedGoal(state, dispatch.data.plan?.goalId)) {
+					room.append("room/delivery-state", {
+						id,
+						dispatchSeq: dispatch.seq,
+						memberId: targetId,
+						state: "cancelled",
+						error: "Goal closed before delivery admission"
+					});
+					await this.ctx.sessions.flush(room);
+					continue;
+				}
+				if (last?.type === "room/delivery-state") {
+					if (last.data.state === "running") {
+						room.append("room/delivery-state", {
+							id,
+							dispatchSeq: dispatch.seq,
+							memberId: targetId,
+							state: "uncertain",
+							error: "Host restarted before a durable settlement; reconcile before retrying"
+						});
+						const target = state.members.find((member) => memberId(events, member) === targetId);
+						if (target !== void 0) {
+							const run = state.runs.find((run) => run.member === target.name);
+							if (run?.state === "running" && (run.runId === void 0 || run.runId === id)) room.append("room/run-state", {
+								member: target.name,
+								state: "failed",
+								startedAt: run.startedAt,
+								...run.runId === void 0 ? {} : { runId: run.runId },
+								error: "Execution outcome is unknown after restart; reconcile before retrying"
+							});
+						}
+						await this.ctx.sessions.flush(room);
+						await this.report(room, dispatch.seq, id, targetId, "uncertain", "Execution outcome is unknown after restart; reconcile before retrying");
+					} else await this.report(room, dispatch.seq, id, targetId, last.data.state, last.data.text ?? last.data.error ?? "");
+					continue;
+				}
+				const target = state.members.find((member) => memberId(events, member) === targetId);
+				if (target !== void 0 && !state.deliveries?.some((row) => row.memberId === targetId && (row.status === "running" || row.status === "uncertain"))) this.dispatch(room, target.name, dispatch.data.text, {
+					dispatchSeq: dispatch.seq,
+					targetId
+				});
+			}
+		}
+	}
+	/** Execute one dispatch: run-state running → member turn → settle edges. */
+	async run(room, memberName, text, options, submitted) {
+		if (this.hooks.allows?.(room, options.dispatchSeq) === false) return;
+		const state = replay(room.snapshotEvents());
+		const member = state.members.find((entry) => options.targetId === void 0 ? entry.name === memberName : memberId(room.snapshotEvents(), entry) === options.targetId);
+		if (member === void 0) return;
+		if (state.deliveries?.some((delivery) => delivery.memberId === member.id && delivery.status === "uncertain")) return;
+		memberName = member.name;
+		const identity = memberId(room.snapshotEvents(), member);
+		const deliveryId = options.dispatchSeq === void 0 ? void 0 : `${options.dispatchSeq}:${identity}`;
+		const runId = deliveryId ?? randomUUID();
+		const cursor = previousCursor(room.snapshotEvents(), memberName, options.dispatchSeq ?? Number.MAX_SAFE_INTEGER);
+		let startedAt;
+		const admitted = async () => {
+			if (startedAt !== void 0) throw new Error("Room delivery was admitted twice");
+			startedAt = Date.now();
+			if (deliveryId !== void 0) room.append("room/delivery-state", {
+				id: deliveryId,
+				dispatchSeq: options.dispatchSeq,
+				memberId: identity,
+				state: "running"
+			});
+			memberName = replay(room.snapshotEvents()).members.find((entry) => memberId(room.snapshotEvents(), entry) === identity)?.name ?? memberName;
+			room.append("room/run-state", {
+				member: memberName,
+				state: "running",
+				startedAt,
+				runId
+			});
+			await this.hooks.admitted?.(room, options.dispatchSeq);
+			await this.ctx.sessions.flush(room);
+			return startedAt;
+		};
+		let outcome;
+		try {
+			outcome = member.kind === "main-agent" ? await this.runMainAgent(room, member, cursor, text, await admitted(), options.relayIds ?? []) : await this.runCliMember(room, member, cursor, text, admitted, options.relayIds ?? [], submitted);
+		} catch (error) {
+			this.ctx.logger.warn(`room: dispatch to "${memberName}" failed: ${String(error)}`);
+			outcome = {
+				state: "failed",
+				error: faultMessage(error)
+			};
+		}
+		outcome = await this.settle(room, member, runId, startedAt ?? Date.now(), outcome);
+		await this.hooks.settled?.(room, options.dispatchSeq, outcome);
+		if (deliveryId !== void 0) {
+			room.append("room/delivery-state", {
+				id: deliveryId,
+				dispatchSeq: options.dispatchSeq,
+				memberId: identity,
+				state: outcome.state,
+				...outcome.text === void 0 ? {} : { text: outcome.text },
+				...outcome.error === void 0 ? {} : { error: outcome.error }
+			});
+			await this.ctx.sessions.flush(room);
+			await this.report(room, options.dispatchSeq, deliveryId, identity, outcome.state, outcome.text ?? outcome.error ?? "");
+		}
+	}
+	async report(room, dispatchSeq, deliveryId, fromId, outcome, text) {
+		const events = room.snapshotEvents();
+		const source = events.find((event) => event.seq === dispatchSeq);
+		if (source?.type !== "room/dispatch" || source.data.origin !== "coordinator" || source.data.replyTo === void 0) return;
+		if (events.some((event) => event.type === "room/dispatch" && event.data.reportFor === deliveryId)) return;
+		const state = replay(events);
+		if (closedGoal(state, source.data.plan?.goalId)) return;
+		const recipient = source.data.plan === void 0 ? state.members.find((member) => memberId(events, member) === source.data.replyTo) : coordinatorMember(state, events);
+		const sender = state.members.find((member) => memberId(events, member) === fromId);
+		if (recipient === void 0) return;
+		const reportText = `Delegation ${deliveryId} (${sender?.name ?? fromId}) ${outcome}.\n${text.slice(0, 32e3)}`;
+		const report = room.append("room/dispatch", {
+			id: randomUUID(),
+			origin: "report",
+			reportFor: deliveryId,
+			targets: [recipient.name],
+			targetIds: [memberId(events, recipient)],
+			text: reportText,
+			...source.data.plan === void 0 ? {} : { plan: { goalId: source.data.plan.goalId } }
+		});
+		await this.ctx.sessions.flush(room);
+		if (this.hooks.allows?.(room, report.seq) !== false) this.dispatch(room, recipient.name, reportText, {
+			dispatchSeq: report.seq,
+			targetId: memberId(events, recipient)
+		});
+	}
+	/**
+	* Mark the relays this run delivered as sent. Delivery = the member's own
+	* session received the prompt (the followup accepted / the CLI run
+	* started): the text lives in the member's private context from then on,
+	* so a later run failure cannot un-deliver it.
+	*/
+	async markSent(room, relays) {
+		if (relays.length === 0) return;
+		for (const relay of relays) room.append("room/relay-resolved", {
+			id: relay.id,
+			state: "sent"
+		});
+		await this.ctx.sessions.flush(room);
+	}
+	/** Main-agent member turn: a producer-sourced followup on the room's own agent. */
+	async runMainAgent(room, member, cursor, text, _startedAt, relayIds) {
+		const agent = this.ctx.agents.get(room.id);
+		if (agent === void 0) return {
+			state: "failed",
+			error: "the room session has no live agent"
+		};
+		const { prompt, carried } = assemblePrompt(room, member, cursor, text, relayIds);
+		agent.followup(createUserMessage({
+			content: [{
+				type: "text",
+				text: prompt
+			}],
+			source: roomSource()
+		}));
+		await this.markSent(room, [...carried, ...replay(room.snapshotEvents()).relays.filter((relay) => relayIds.includes(relay.id))]);
+		await agent.whenIdle();
+		return { state: "done" };
+	}
+	/** CLI member turn: facade start (first round) or resume, then the speech mirror. */
+	async runCliMember(room, member, cursor, text, admitted, relayIds, submitted) {
+		const facade = probeLocalAgent(this.ctx);
+		if (facade === void 0) {
+			this.ctx.logger.warn(`room: cannot dispatch to "${member.name}": local-agent facade unavailable`);
+			throw new Error("the local-agent delegation facade is unavailable");
+		}
+		const provider = member.provider ?? "";
+		let startedAt;
+		const controlled = facade.supportsMemberConfiguration?.(provider) === true;
+		const admission = controlled ? { onAdmitted: async () => {
+			startedAt = await admitted();
+		} } : {};
+		if (!controlled) startedAt = await admitted();
+		const { prompt, carried } = assemblePrompt(room, member, cursor, text, relayIds);
+		const prepared = member.childSessionId !== void 0 && facade.isPreparedMember?.(member.childSessionId) === true;
+		const pendingRun = prepared ? facade.start(room.id, provider, [{
+			type: "text",
+			text: prompt
+		}], {
+			preparedMemberId: member.childSessionId,
+			...admission
+		}) : member.childSessionId === void 0 ? facade.start(room.id, provider, [{
+			type: "text",
+			text: prompt
+		}], member.model === void 0 && member.cwd === void 0 && !controlled ? void 0 : {
+			...admission,
+			...member.model === void 0 ? {} : { model: member.model },
+			...member.cwd === void 0 ? {} : { cwd: member.cwd }
+		}) : facade.resume(room.id, provider, member.childSessionId, [{
+			type: "text",
+			text: prompt
+		}], member.cwd === void 0 && !controlled ? void 0 : {
+			...admission,
+			...member.cwd === void 0 ? {} : { cwd: member.cwd }
+		});
+		if (controlled && member.childSessionId !== void 0 && !prepared) submitted();
+		const run = await pendingRun;
+		if (startedAt === void 0) {
+			await run.dispose();
+			throw new Error("Provider published a room run without admission");
+		}
+		try {
+			if (member.childSessionId === void 0) room.append("room/member-updated", {
+				name: replay(room.snapshotEvents()).members.find((entry) => entry.id === member.id)?.name ?? member.name,
+				childSessionId: run.id
+			});
+			await this.markSent(room, [...carried, ...replay(room.snapshotEvents()).relays.filter((relay) => relayIds.includes(relay.id))]);
+			await this.ctx.sessions.flush(room);
+		} catch (error) {
+			await run.result.catch(() => {});
+			throw error;
+		}
+		if (controlled) submitted();
+		const result = await run.result;
+		const output = runOutputText(result.output);
+		const interrupted = result.stopReason === "completed" ? void 0 : result.stopReason === "aborted" ? "cancelled" : "failed";
+		const speech = output !== "" || interrupted === void 0 ? room.append("room/speech", {
+			member: replay(room.snapshotEvents()).members.find((entry) => entry.id === member.id)?.name ?? member.name,
+			text: output,
+			childSessionId: run.id,
+			durationMs: Date.now() - startedAt,
+			...interrupted === void 0 ? {} : { interrupted }
+		}) : void 0;
+		if (speech !== void 0) await this.ctx.sessions.flush(room);
+		if (result.stopReason === "completed") {
+			const directive = parseRelayDirective(runOutputText(result.output));
+			const roster = replay(room.snapshotEvents()).members;
+			if (directive !== void 0 && directive.to !== member.name && roster.some((entry) => entry.name === directive.to)) room.append("room/relay", {
+				id: randomUUID(),
+				from: member.name,
+				to: directive.to,
+				content: directive.content,
+				provenance: {
+					kind: "speech-fallback",
+					speechSeq: speech.seq
+				}
+			});
+			await this.ctx.sessions.flush(room);
+			return {
+				state: "done",
+				text: runOutputText(result.output)
+			};
+		} else if (result.stopReason === "aborted") return {
+			state: "cancelled",
+			text: output
+		};
+		else return {
+			state: "failed",
+			text: output,
+			error: `the member run ended with stopReason "${result.stopReason}"`
+		};
+	}
+	/** Settle only this execution and its own task rows, preserving newer runs. */
+	async settle(room, member, runId, startedAt, outcome) {
+		const events = room.snapshotEvents();
+		const memberName = replay(events).members.find((entry) => memberId(events, entry) === memberId(events, member))?.name ?? member.name;
+		const terminal = events.find((event) => event.type === "room/run-state" && event.data.runId === runId && event.data.state !== "running");
+		if (terminal?.type === "room/run-state" && terminal.data.state !== "running") return {
+			...outcome,
+			state: terminal.data.state,
+			...terminal.data.error === void 0 ? {} : { error: terminal.data.error }
+		};
+		room.append("room/run-state", {
+			member: memberName,
+			runId,
+			state: outcome.state,
+			startedAt,
+			elapsedMs: Date.now() - startedAt,
+			...outcome.error === void 0 ? {} : { error: outcome.error }
+		});
+		for (const task of replay(room.snapshotEvents()).tasks) if (task.member === memberName && task.status === "in_progress" && task.deliveryId === runId) room.append("room/task-updated", {
+			id: task.id,
+			status: outcome.state
+		});
+		await this.ctx.sessions.flush(room);
+		return outcome;
+	}
+};
+//#endregion
+//#region lib/types/index.js
+/**
+* room host half: the `room` Typert Remote service. (The `room_invite` /
+* `room_task` / `room_message` model tools left this package's profile-root
+* registration in the M4' tool-row split — their definition factories live
+* in ./tool.ts and the companion `@khorsheed/dsh-room-tool` mounts them
+* inside agent-preset compositions.) The room's entire state is the session's `room/*` custom-event
+* journal (log-only events — persistence and reload-replay come free, the
+* model never sees them, and harnesses without this plugin replay the session
+* safely); every read folds the journal through the pure replay, and every
+* mutating Remote appends and flushes. Dispatch records and first tasks are
+* executed by the DispatchEngine: main-agent members get a producer-sourced
+* followup on the room's own agent, CLI members go through the probed
+* local-agent delegation facade (absent facade = degraded CLI capability,
+* never a boot failure). The member-notification gate lives here too: the
+* local-agent bridge duck-type-calls `receiveMemberMessage` (service face via
+* ctx.provide, off the wire), the human confirms/dismisses through the
+* confirmRelay/dismissRelay Remotes.
+* @module @khorsheed/dsh-room
+*/
+var __runInitializers = function(thisArg, initializers, value) {
+	var useValue = arguments.length > 2;
+	for (var i = 0; i < initializers.length; i++) value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+	return useValue ? value : void 0;
+};
+var __esDecorate = function(ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+	function accept(f) {
+		if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected");
+		return f;
+	}
+	var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+	var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+	var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+	var _, done = false;
+	for (var i = decorators.length - 1; i >= 0; i--) {
+		var context = {};
+		for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+		for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+		context.addInitializer = function(f) {
+			if (done) throw new TypeError("Cannot add initializers after decoration has completed");
+			extraInitializers.push(accept(f || null));
+		};
+		var result = (0, decorators[i])(kind === "accessor" ? {
+			get: descriptor.get,
+			set: descriptor.set
+		} : descriptor[key], context);
+		if (kind === "accessor") {
+			if (result === void 0) continue;
+			if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+			if (_ = accept(result.get)) descriptor.get = _;
+			if (_ = accept(result.set)) descriptor.set = _;
+			if (_ = accept(result.init)) initializers.unshift(_);
+		} else if (_ = accept(result)) {
+			if (kind === "field") initializers.unshift(_);
+			else descriptor[key] = _;
+		}
+	}
+	if (target) Object.defineProperty(target, contextIn.name, descriptor);
+	done = true;
+};
+var __rewriteRelativeImportExtension = function(path, preserveJsx) {
+	if (typeof path === "string" && /^\.\.?\//.test(path)) return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function(m, tsx, d, ext, cm) {
+		return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : d + ext + "." + cm.toLowerCase() + "js";
+	});
+	return path;
+};
+const catalogSpecifier = [
+	"@deepseek-ai/dsh-session",
+	"src",
+	"known-event-types"
+].join("/");
+const catalogModule = await import(__rewriteRelativeImportExtension(catalogSpecifier)).catch(() => import("@deepseek-ai/dsh-session"));
+for (const type of ROOM_EVENT_TYPES) catalogModule.KNOWN_SESSION_EVENT_TYPES.add(type);
+/** Addressing/display names must stay parseable by the composer @-grammar. */
+function validName(name) {
+	return name !== "" && !/\s/.test(name) && !name.includes("@");
+}
+/** A task title is the dispatch text's first line, truncated. */
+function taskTitle(text) {
+	const first = text.trim().split("\n", 1)[0] ?? "";
+	return first.length > 60 ? `${first.slice(0, 60)}…` : first;
+}
+/**
+* room Remote service: promotion, roster management, the human @-message
+* intake, the notification gate, the task board, and run cancellation. A
+* room IS a normal session; the journal is its only state. A room is never
+* CREATED apart from a session — inviting an agent into any session promotes
+* it (see ensureRoom; the room-session-promotion proposal).
+*/
+let RoomService = (() => {
+	let _classSuper = TypertRemoteService;
+	let _instanceExtraInitializers = [];
+	let _isRoom_decorators;
+	let _listProviders_decorators;
+	let _getState_decorators;
+	let _invite_decorators;
+	let _updateMember_decorators;
+	let _prepareMember_decorators;
+	let _reconcileDelivery_decorators;
+	let _setCoordinator_decorators;
+	let _removeMember_decorators;
+	let _postMessage_decorators;
+	let _planCommand_decorators;
+	let _confirmRelay_decorators;
+	let _dismissRelay_decorators;
+	let _addTask_decorators;
+	let _closeTask_decorators;
+	let _setGoal_decorators;
+	let _cancel_decorators;
+	return class RoomService extends _classSuper {
+		static {
+			const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+			_isRoom_decorators = [Remote("isRoom")];
+			_listProviders_decorators = [Remote("listProviders")];
+			_getState_decorators = [Remote("getState")];
+			_invite_decorators = [Remote("invite")];
+			_updateMember_decorators = [Remote("updateMember")];
+			_prepareMember_decorators = [Remote("prepareMember")];
+			_reconcileDelivery_decorators = [Remote("reconcileDelivery")];
+			_setCoordinator_decorators = [Remote("setCoordinator")];
+			_removeMember_decorators = [Remote("removeMember")];
+			_postMessage_decorators = [Remote("postMessage")];
+			_planCommand_decorators = [Remote("planCommand")];
+			_confirmRelay_decorators = [Remote("confirmRelay")];
+			_dismissRelay_decorators = [Remote("dismissRelay")];
+			_addTask_decorators = [Remote("addTask")];
+			_closeTask_decorators = [Remote("closeTask")];
+			_setGoal_decorators = [Remote("setGoal")];
+			_cancel_decorators = [Remote("cancel")];
+			__esDecorate(this, null, _isRoom_decorators, {
+				kind: "method",
+				name: "isRoom",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "isRoom" in obj,
+					get: (obj) => obj.isRoom
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _listProviders_decorators, {
+				kind: "method",
+				name: "listProviders",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "listProviders" in obj,
+					get: (obj) => obj.listProviders
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _getState_decorators, {
+				kind: "method",
+				name: "getState",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "getState" in obj,
+					get: (obj) => obj.getState
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _invite_decorators, {
+				kind: "method",
+				name: "invite",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "invite" in obj,
+					get: (obj) => obj.invite
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _updateMember_decorators, {
+				kind: "method",
+				name: "updateMember",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "updateMember" in obj,
+					get: (obj) => obj.updateMember
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _prepareMember_decorators, {
+				kind: "method",
+				name: "prepareMember",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "prepareMember" in obj,
+					get: (obj) => obj.prepareMember
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _reconcileDelivery_decorators, {
+				kind: "method",
+				name: "reconcileDelivery",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "reconcileDelivery" in obj,
+					get: (obj) => obj.reconcileDelivery
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _setCoordinator_decorators, {
+				kind: "method",
+				name: "setCoordinator",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "setCoordinator" in obj,
+					get: (obj) => obj.setCoordinator
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _removeMember_decorators, {
+				kind: "method",
+				name: "removeMember",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "removeMember" in obj,
+					get: (obj) => obj.removeMember
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _postMessage_decorators, {
+				kind: "method",
+				name: "postMessage",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "postMessage" in obj,
+					get: (obj) => obj.postMessage
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _planCommand_decorators, {
+				kind: "method",
+				name: "planCommand",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "planCommand" in obj,
+					get: (obj) => obj.planCommand
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _confirmRelay_decorators, {
+				kind: "method",
+				name: "confirmRelay",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "confirmRelay" in obj,
+					get: (obj) => obj.confirmRelay
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _dismissRelay_decorators, {
+				kind: "method",
+				name: "dismissRelay",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "dismissRelay" in obj,
+					get: (obj) => obj.dismissRelay
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _addTask_decorators, {
+				kind: "method",
+				name: "addTask",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "addTask" in obj,
+					get: (obj) => obj.addTask
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _closeTask_decorators, {
+				kind: "method",
+				name: "closeTask",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "closeTask" in obj,
+					get: (obj) => obj.closeTask
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _setGoal_decorators, {
+				kind: "method",
+				name: "setGoal",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "setGoal" in obj,
+					get: (obj) => obj.setGoal
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _cancel_decorators, {
+				kind: "method",
+				name: "cancel",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "cancel" in obj,
+					get: (obj) => obj.cancel
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			if (_metadata) Object.defineProperty(this, Symbol.metadata, {
+				enumerable: true,
+				configurable: true,
+				writable: true,
+				value: _metadata
+			});
+		}
+		static inject = ["sessions", "agents"];
+		/** The dispatch engine executing this service's dispatch records. */
+		plans = __runInitializers(this, _instanceExtraInitializers);
+		engine;
+		handoffs = /* @__PURE__ */ new Set();
+		/** sessionId → in-flight cold resume (mutations on a cold room dedupe). */
+		resumes = /* @__PURE__ */ new Map();
+		/**
+		* @param ctx - host context carrying the session store.
+		*/
+		constructor(ctx) {
+			super(ctx, "room");
+			ctx.effect(async () => {
+				await preloadPresetDerivationHost();
+				return () => {};
+			}, "room: preset-registry probe");
+			ctx.effect(async () => {
+				const loader = ctx.get("loader");
+				if (loader?.import === void 0) return () => {};
+				for (const specifier of ["@deepseek-ai/dsh-session", catalogSpecifier]) try {
+					const catalog = await loader.import(specifier);
+					for (const type of ROOM_EVENT_TYPES) catalog.KNOWN_SESSION_EVENT_TYPES?.add(type);
+				} catch {}
+				return () => {};
+			}, "room: runtime event vocabulary");
+			this.plans = new PlanService(ctx, () => this.engine);
+			this.engine = new DispatchEngine(ctx, {
+				allows: (room, seq) => this.plans.allows(room, seq),
+				admitted: (room, seq) => this.plans.admitted(room, seq),
+				settled: (room, seq, outcome) => this.plans.settled(room, seq, outcome)
+			});
+			ctx.effect(() => () => this.plans.dispose());
+			const nativeTurns = /* @__PURE__ */ new WeakMap();
+			ctx.on("agent/pre-step", async ({ agent, messages, turn, step }, next) => {
+				const events = agent.session.snapshotEvents();
+				if (!isRoomLog(events) || coordinatorMember(replay(events), events)?.kind !== "cli") return next();
+				if (nativeTurns.get(agent) === turn) return next();
+				if (step !== 1) throw new Error("Room native turn has no explicit member dispatch");
+				if (messages.some((message) => isRoomSource(message.source))) {
+					nativeTurns.set(agent, turn);
+					return next();
+				}
+				for (const message of messages) {
+					if (message.source.kind !== "user" || message.content.some((block) => block.type !== "text")) throw new Error("Use the room input route for this coordinator; this input cannot be forwarded losslessly");
+					const result = await this.postMessage({
+						sessionId: agent.session.id,
+						requestId: String(message.id),
+						text: message.content.map((block) => block.type === "text" ? block.text : "").join("\n")
+					});
+					if (!result.ok) throw new Error(`Room input routing failed: ${result.error.code}`);
+				}
+				return {
+					kind: "enter",
+					messages: []
+				};
+			});
+		}
+		/** Resolve a LIVE session as a room: presence, marker, replayed state. */
+		load(sessionId) {
+			const session = this.ctx.sessions.get(sessionId);
+			if (session === void 0) return {
+				ok: false,
+				error: { code: "session-not-found" }
+			};
+			if (!isRoomLog(session.snapshotEvents())) return {
+				ok: false,
+				error: { code: "not-a-room" }
+			};
+			return {
+				ok: true,
+				session,
+				state: replay(session.snapshotEvents())
+			};
+		}
+		/**
+		* Read a session as a room without side effects: the live store first, then
+		* a persistence inspection (a cold room after a host restart answers from
+		* its durable log; nothing is attached or resumed on a read).
+		*/
+		async loadCold(sessionId) {
+			const live = this.ctx.sessions.get(sessionId);
+			if (live !== void 0) return isRoomLog(live.snapshotEvents()) ? {
+				ok: true,
+				state: replay(live.snapshotEvents()),
+				preset: roomSessionPreset(live)
+			} : {
+				ok: false,
+				error: { code: "not-a-room" }
+			};
+			const inspected = await inspectCold(this.ctx, sessionId);
+			if (inspected === void 0) return {
+				ok: false,
+				error: { code: "session-not-found" }
+			};
+			if (!isRoomLog(inspected.events)) return {
+				ok: false,
+				error: { code: "not-a-room" }
+			};
+			return {
+				ok: true,
+				state: replay(inspected.events),
+				preset: deriveSessionPreset(presetDerivationHost(), {
+					header: inspected.meta,
+					events: inspected.events
+				})
+			};
+		}
+		/**
+		* Resolve a room for a MUTATION: the session must be live to take appends,
+		* and dispatch needs its agent live (the delegation facade resolves the
+		* parent through `ctx.agents.get` — live agents only). A cold room is
+		* cold-resumed through the agent factory, which republishes session +
+		* agent under the preset the log records; resumes dedupe per session.
+		*/
+		ensureLive(sessionId) {
+			const hit = this.load(sessionId);
+			if (hit.ok) return (async () => {
+				await this.plans.recover(hit.session);
+				await this.engine.recover(hit.session);
+				return this.load(sessionId);
+			})();
+			if (hit.error.code !== "session-not-found") return Promise.resolve(hit);
+			let pending = this.resumes.get(sessionId);
+			if (pending === void 0) {
+				pending = this.resumeRoom(sessionId).finally(() => this.resumes.delete(sessionId));
+				this.resumes.set(sessionId, pending);
+			}
+			return pending;
+		}
+		/** One cold resume: refuse non-rooms before paying an agent composition. */
+		async resumeRoom(sessionId) {
+			const cold = await this.loadCold(sessionId);
+			if (!cold.ok) return cold;
+			try {
+				const composition = await composeRoomAgent(this.ctx, cold.preset);
+				await this.ctx.agents.resume({
+					resumeSessionId: sessionId,
+					...composition.setup === void 0 ? {} : { setup: composition.setup }
+				});
+			} catch (error) {
+				return {
+					ok: false,
+					error: {
+						code: "resume-failed",
+						message: String(error)
+					}
+				};
+			}
+			const loaded = this.load(sessionId);
+			if (loaded.ok) {
+				await this.plans.recover(loaded.session);
+				await this.engine.recover(loaded.session);
+			}
+			return loaded;
+		}
+		/**
+		* Probe whether a session is a room: replay its event log looking for the
+		* `room/created` marker. Side-effect-free: a cold session answers from a
+		* persistence inspection, so opening any session never resumes its agent.
+		* @param request - session identity.
+		* @returns true when the session carries the marker (false for unknown sessions too).
+		*/
+		async isRoom(request) {
+			const session = this.ctx.sessions.get(request.sessionId);
+			if (session !== void 0) return isRoomLog(session.snapshotEvents());
+			const inspected = await inspectCold(this.ctx, request.sessionId);
+			return inspected !== void 0 && isRoomLog(inspected.events);
+		}
+		/**
+		* Resolve a session for a room WRITE, promoting it when it isn't a room
+		* yet: a live plain session gains the `room/created` identity marker and
+		* the main agent's roster seat (the promotion IS the entry model — the
+		* room-session-promotion proposal: any session an agent is invited into
+		* becomes a room). Idempotent — an existing room passes through untouched,
+		* and concurrent promotions converge on the log (the first `room/created`
+		* wins identity). A cold EXISTING room resumes through the normal path;
+		* a cold PLAIN session cannot be promoted sight-unseen (promotion writes
+		* on the live session, and the surfaces that promote — the open session's
+		* invite dialog, the room tools running in their own session — always hold
+		* it live), so it answers `not-a-room`. NOT a Remote — the surfaces reach
+		* it through the write paths (invite/messageMember); public so tests and a
+		* future manual "promote" surface share the one entry.
+		* @param sessionId - the session to write.
+		* @returns the live session plus replayed state, or the rejection.
+		*/
+		async ensureRoom(sessionId) {
+			const live = this.ctx.sessions.get(sessionId);
+			if (live === void 0) {
+				const cold = await this.loadCold(sessionId);
+				if (!cold.ok) return {
+					ok: false,
+					error: cold.error
+				};
+				return this.ensureLive(sessionId);
+			}
+			if (!isRoomLog(live.snapshotEvents())) {
+				live.append("room/created", { version: 1 });
+				live.append("room/member-added", {
+					name: "dsh",
+					kind: "main-agent",
+					invitedBy: "human"
+				});
+				await this.ctx.sessions.flush(live);
+			}
+			return {
+				ok: true,
+				session: live,
+				state: replay(live.snapshotEvents())
+			};
+		}
+		/**
+		* List the invitable CLI providers: the local-agent roster with each
+		* harness's auth state, plus the delegation-facade verdict (absent facade =
+		* CLI members undispatchable; the dialog greys the section instead of
+		* failing). Harnesses without a delegation provider are record-only and
+		* are not invitable.
+		* @param _request - no parameters.
+		* @returns the provider list and the facade verdict.
+		*/
+		async listProviders(_request) {
+			const localAgentAvailable = probeLocalAgent(this.ctx) !== void 0;
+			const roster = probeLocalAgentRoster(this.ctx);
+			if (roster === void 0) return {
+				localAgentAvailable,
+				providers: []
+			};
+			const providers = [];
+			for (const row of roster.roster()) {
+				const status = await roster.statusOf(row.name);
+				if (status.delegationProvider === void 0) continue;
+				providers.push({
+					provider: status.delegationProvider,
+					displayName: row.displayName,
+					harness: row.name,
+					authenticated: status.authenticated
+				});
+			}
+			return {
+				localAgentAvailable,
+				providers
+			};
+		}
+		/**
+		* Replay the room's journal into the derived state (roster, notification
+		* relays, task board, run states).
+		* @param request - room session identity.
+		* @returns the replayed state, or a rejection from the closed failure union.
+		*/
+		async getState(request) {
+			const loaded = await this.loadCold(request.sessionId);
+			if (!loaded.ok) return {
+				ok: false,
+				error: loaded.error
+			};
+			return {
+				ok: true,
+				value: {
+					...this.engine.view(request.sessionId, loaded.state),
+					...loaded.state.plan === void 0 ? {} : { plan: this.plans.view(request.sessionId, loaded.state.plan) }
+				}
+			};
+		}
+		/**
+		* Validate, PROMOTE (a plain session becomes a room — see ensureRoom), and
+		* journal an invitation: the name must be parseable by the
+		* composer @-grammar and unique, the provider non-blank AND a registered
+		* delegation provider (the classic slip is the harness name `kimi` where
+		* the family registered `kimi-cli` — validated against the roster's
+		* `delegationProvider` set, the same probe listProviders serves; a roster-
+		* less core skips the check, degrading to the old accept-anything), and
+		* (CLI members are undispatchable without it) the local-agent facade must
+		* be probed. A first task is journaled as a `room/dispatch` (auto-opening
+		* the member's in_progress task) and handed to the engine immediately —
+		* the receipt's `pendingFirstTask` means "dispatched". Shared by the
+		* Remote surface (`invitedBy: 'human'`) and the room_invite tool
+		* (`invitedBy: 'agent'`).
+		* @param request - room session, provider, name, optional cwd, instructions and first task.
+		* @param invitedBy - the invitation's origin.
+		* @returns the invitation receipt, or a rejection.
+		*/
+		async inviteMember(request, invitedBy, actorChildSessionId) {
+			const loaded = await this.ensureRoom(request.sessionId);
+			if (!loaded.ok) return {
+				ok: false,
+				error: loaded.error
+			};
+			if (this.handoffs.has(request.sessionId)) return {
+				ok: false,
+				error: { code: "coordinator-busy" }
+			};
+			if (invitedBy === "agent" && !this.isCurrentCoordinator(loaded.session, actorChildSessionId)) return {
+				ok: false,
+				error: { code: "not-coordinator" }
+			};
+			if (!validName(request.name)) return {
+				ok: false,
+				error: { code: "invalid-name" }
+			};
+			if (loaded.state.members.some((member) => member.name === request.name)) return {
+				ok: false,
+				error: { code: "duplicate-name" }
+			};
+			if (request.provider.trim() === "") return {
+				ok: false,
+				error: { code: "empty-provider" }
+			};
+			if (request.instructions !== void 0 && request.instructions.trim() === "") return {
+				ok: false,
+				error: { code: "empty-text" }
+			};
+			if (request.firstTask !== void 0 && request.firstTask.trim() === "") return {
+				ok: false,
+				error: { code: "empty-text" }
+			};
+			if (request.model !== void 0 && request.model.trim() === "") return {
+				ok: false,
+				error: { code: "empty-text" }
+			};
+			if (probeLocalAgent(this.ctx) === void 0) return {
+				ok: false,
+				error: { code: "local-agent-unavailable" }
+			};
+			const roster = probeLocalAgentRoster(this.ctx);
+			if (roster !== void 0) {
+				const available = [];
+				for (const row of roster.roster()) {
+					const status = await roster.statusOf(row.name);
+					if (status.delegationProvider !== void 0) available.push(status.delegationProvider);
+				}
+				if (!available.includes(request.provider)) return {
+					ok: false,
+					error: {
+						code: "unknown-provider",
+						provider: request.provider,
+						available
+					}
+				};
+			}
+			if (this.handoffs.has(request.sessionId)) return {
+				ok: false,
+				error: { code: "coordinator-busy" }
+			};
+			if (invitedBy === "agent" && !this.isCurrentCoordinator(loaded.session, actorChildSessionId)) return {
+				ok: false,
+				error: { code: "not-coordinator" }
+			};
+			if (replay(loaded.session.snapshotEvents()).members.some((member) => member.name === request.name)) return {
+				ok: false,
+				error: { code: "duplicate-name" }
+			};
+			loaded.session.append("room/member-added", {
+				id: randomUUID(),
+				name: request.name,
+				kind: "cli",
+				provider: request.provider,
+				invitedBy,
+				...request.instructions === void 0 ? {} : { instructions: request.instructions },
+				...request.cwd === void 0 || request.cwd.trim() === "" ? {} : { cwd: request.cwd.trim() },
+				...request.model === void 0 || request.model.trim() === "" ? {} : { model: request.model.trim() }
+			});
+			let firstTaskSeq;
+			if (request.firstTask !== void 0) {
+				firstTaskSeq = loaded.session.append("room/dispatch", {
+					id: randomUUID(),
+					origin: invitedBy === "human" ? "human" : "coordinator",
+					...invitedBy === "human" ? {} : { replyTo: memberId(loaded.session.snapshotEvents(), coordinatorMember(replay(loaded.session.snapshotEvents()), loaded.session.snapshotEvents())) },
+					targetIds: [memberId(loaded.session.snapshotEvents(), replay(loaded.session.snapshotEvents()).members.find((member) => member.name === request.name))],
+					targets: [request.name],
+					text: request.firstTask
+				}).seq;
+				loaded.session.append("room/task-added", {
+					id: randomUUID(),
+					member: request.name,
+					title: taskTitle(request.firstTask),
+					status: "in_progress",
+					deliveryId: `${firstTaskSeq}:${memberId(loaded.session.snapshotEvents(), replay(loaded.session.snapshotEvents()).members.find((member) => member.name === request.name))}`
+				});
+			}
+			await this.ctx.sessions.flush(loaded.session);
+			if (request.firstTask !== void 0 && firstTaskSeq !== void 0) this.engine.dispatch(loaded.session, request.name, request.firstTask, { dispatchSeq: firstTaskSeq });
+			return {
+				ok: true,
+				value: {
+					name: request.name,
+					pendingFirstTask: request.firstTask !== void 0
+				}
+			};
+		}
+		/**
+		* Invite a CLI member (the human path; see inviteMember).
+		* @param request - room session, provider, name, optional cwd, instructions and first task.
+		* @returns the invitation receipt, or a rejection.
+		*/
+		invite(request) {
+			return this.inviteMember(request, "human");
+		}
+		/**
+		* Update a member's editable fields: rename (validated like an invite name —
+		* unique, parseable; the main agent is the room itself and cannot be
+		* renamed), role instructions (null or a blank text CLEARS them — later
+		* dispatches inject none), the member-level cwd override (null or a
+		* blank text clears back to inheriting the room cwd; still roster-recorded
+		* only — the delegation facade's per-call cwd override is the family's open
+		* R2), and the intended model (null or a blank text clears it back to the
+		* harness default; roster-recorded intent — the first dispatch binds it as
+		* the facade start's `model` option, and the live member's immediate switch
+		* is the client's localAgentGateway `setMemberModel` call, not this one).
+		* An instructions edit rides the member's next dispatch as a context
+		* update (the CLI session itself is never rewritten); a rename migrates
+		* every name-keyed projection at replay (the journal fold moves the roster
+		* key, tasks' member/blockedBy, relays' from/to, and the runs key).
+		* @param request - room session, member name, and the fields to change.
+		* @returns the update receipt (the CURRENT name), or a rejection.
+		*/
+		async updateMember(request) {
+			const loaded = await this.ensureLive(request.sessionId);
+			if (!loaded.ok) return {
+				ok: false,
+				error: loaded.error
+			};
+			if (this.handoffs.has(request.sessionId)) return {
+				ok: false,
+				error: { code: "coordinator-busy" }
+			};
+			const member = loaded.state.members.find((entry) => entry.name === request.name);
+			if (member === void 0) return {
+				ok: false,
+				error: { code: "member-not-found" }
+			};
+			if (request.cwd !== void 0 && (member.childSessionId !== void 0 || this.engine.hasPending(loaded.session, member.name))) return {
+				ok: false,
+				error: { code: "member-cwd-bound" }
+			};
+			if (request.model !== void 0 && member.childSessionId !== void 0) return {
+				ok: false,
+				error: { code: "configuration-owned-by-core" }
+			};
+			if (request.rename === void 0 && request.instructions === void 0 && request.cwd === void 0 && request.model === void 0) return {
+				ok: false,
+				error: { code: "nothing-to-update" }
+			};
+			if (request.rename !== void 0 && request.rename !== request.name) {
+				if (member.kind === "main-agent") return {
+					ok: false,
+					error: { code: "main-member" }
+				};
+				if (!validName(request.rename)) return {
+					ok: false,
+					error: { code: "invalid-name" }
+				};
+				if (loaded.state.members.some((entry) => entry.name === request.rename)) return {
+					ok: false,
+					error: { code: "duplicate-name" }
+				};
+			}
+			const instructions = typeof request.instructions === "string" && request.instructions.trim() === "" ? null : request.instructions;
+			const cwd = typeof request.cwd === "string" ? request.cwd.trim() === "" ? null : request.cwd.trim() : request.cwd;
+			const model = typeof request.model === "string" ? request.model.trim() === "" ? null : request.model.trim() : request.model;
+			loaded.session.append("room/member-updated", {
+				name: request.name,
+				...request.rename === void 0 ? {} : { rename: request.rename },
+				...instructions === void 0 ? {} : { instructions },
+				...cwd === void 0 ? {} : { cwd },
+				...model === void 0 ? {} : { model }
+			});
+			await this.ctx.sessions.flush(loaded.session);
+			return {
+				ok: true,
+				value: { name: request.name }
+			};
+		}
+		/** Native preparation creates no unrelated conversation turn and leaves the role unchanged. */
+		async prepareMember(request) {
+			if (this.handoffs.has(request.sessionId)) return {
+				ok: false,
+				error: { code: "coordinator-busy" }
+			};
+			this.handoffs.add(request.sessionId);
+			try {
+				return await this.prepareMemberInRoom(request);
+			} finally {
+				this.handoffs.delete(request.sessionId);
+			}
+		}
+		async prepareMemberInRoom(request) {
+			const loaded = await this.ensureLive(request.sessionId);
+			if (!loaded.ok) return {
+				ok: false,
+				error: loaded.error
+			};
+			const member = loaded.state.members.find((member) => member.name === request.name);
+			if (member?.kind !== "cli" || member.provider === void 0) return {
+				ok: false,
+				error: { code: "member-not-found" }
+			};
+			const family = probeLocalAgent(this.ctx);
+			if (family?.prepareMember === void 0) return {
+				ok: false,
+				error: {
+					code: "coordinator-not-ready",
+					message: "Native preparation is unavailable in this family core"
+				}
+			};
+			try {
+				const childSessionId = await family.prepareMember(request.sessionId, member.provider, member.childSessionId ?? memberId(loaded.session.snapshotEvents(), member), {
+					...member.cwd === void 0 ? {} : { cwd: member.cwd },
+					...member.model === void 0 ? {} : { model: member.model }
+				});
+				loaded.session.append("room/member-updated", {
+					name: member.name,
+					childSessionId: SessionId(childSessionId)
+				});
+				await this.ctx.sessions.flush(loaded.session);
+				return {
+					ok: true,
+					value: { childSessionId }
+				};
+			} catch (error) {
+				return {
+					ok: false,
+					error: {
+						code: "coordinator-not-ready",
+						message: String(error)
+					}
+				};
+			}
+		}
+		/** A human records the known result before releasing a crashed member's queued work. */
+		async reconcileDelivery(request) {
+			const loaded = await this.ensureLive(request.sessionId);
+			if (!loaded.ok) return {
+				ok: false,
+				error: loaded.error
+			};
+			const delivery = loaded.state.deliveries?.find((row) => row.id === request.deliveryId);
+			if (delivery?.status !== "uncertain") return {
+				ok: false,
+				error: { code: "delivery-not-uncertain" }
+			};
+			if (delivery.plan?.taskId !== void 0) return {
+				ok: false,
+				error: { code: "plan-reconciliation-required" }
+			};
+			if (request.evidence.trim() === "") return {
+				ok: false,
+				error: { code: "empty-text" }
+			};
+			loaded.session.append("room/delivery-state", {
+				id: delivery.id,
+				dispatchSeq: delivery.dispatchSeq,
+				memberId: delivery.memberId,
+				state: request.outcome,
+				text: request.evidence.trim()
+			});
+			const run = loaded.state.runs.find((run) => run.runId === delivery.id);
+			if (run !== void 0) loaded.session.append("room/run-state", {
+				member: run.member,
+				runId: delivery.id,
+				startedAt: run.startedAt,
+				state: request.outcome
+			});
+			await this.ctx.sessions.flush(loaded.session);
+			await this.engine.recover(loaded.session);
+			return { ok: true };
+		}
+		/** Explicit human role change; state is committed only after readiness and idle checks. */
+		async setCoordinator(request) {
+			if (this.handoffs.has(request.sessionId)) return {
+				ok: false,
+				error: { code: "coordinator-busy" }
+			};
+			this.handoffs.add(request.sessionId);
+			try {
+				const loaded = await this.ensureLive(request.sessionId);
+				if (!loaded.ok) return {
+					ok: false,
+					error: loaded.error
+				};
+				const events = loaded.session.snapshotEvents();
+				let candidate = loaded.state.members.find((member) => memberId(events, member) === request.memberId);
+				const previous = coordinatorMember(loaded.state, events);
+				if (candidate === void 0 || previous === void 0) return {
+					ok: false,
+					error: { code: "member-not-found" }
+				};
+				if ((loaded.state.coordinator?.revision ?? 0) !== request.expectedRevision) return {
+					ok: false,
+					error: { code: "coordinator-conflict" }
+				};
+				const agent = this.ctx.agents.get(request.sessionId);
+				if (agent?.status === "running" || (agent?.inbox?.nextTurn.length ?? 0) > 0 || (agent?.inbox?.nextStep.length ?? 0) > 0 || this.engine.hasPending(loaded.session, previous.name) || this.engine.hasPending(loaded.session, candidate.name)) return {
+					ok: false,
+					error: { code: "coordinator-busy" }
+				};
+				if (candidate.kind === "cli" && candidate.childSessionId === void 0) {
+					const prepared = await this.prepareMemberInRoom({
+						sessionId: request.sessionId,
+						name: candidate.name
+					});
+					if (!prepared.ok) return {
+						ok: false,
+						error: prepared.error
+					};
+					candidate = {
+						...candidate,
+						childSessionId: SessionId(prepared.value.childSessionId)
+					};
+				}
+				const refreshedEvents = loaded.session.snapshotEvents();
+				const refreshed = replay(refreshedEvents);
+				candidate = refreshed.members.find((member) => memberId(refreshedEvents, member) === request.memberId);
+				if (candidate === void 0) return {
+					ok: false,
+					error: { code: "member-not-found" }
+				};
+				if ((refreshed.coordinator?.revision ?? 0) !== request.expectedRevision) return {
+					ok: false,
+					error: { code: "coordinator-conflict" }
+				};
+				const refreshedAgent = this.ctx.agents.get(request.sessionId);
+				if (refreshedAgent?.status === "running" || (refreshedAgent?.inbox?.nextTurn.length ?? 0) > 0 || (refreshedAgent?.inbox?.nextStep.length ?? 0) > 0 || this.engine.hasPending(loaded.session, previous.name) || this.engine.hasPending(loaded.session, candidate.name)) return {
+					ok: false,
+					error: { code: "coordinator-busy" }
+				};
+				if (candidate.kind === "cli") {
+					const family = this.ctx.get("localAgent");
+					if (candidate.childSessionId === void 0 || family?.canCoordinateRoom?.(candidate.childSessionId) !== true) return {
+						ok: false,
+						error: {
+							code: "coordinator-not-ready",
+							message: "The member coordination tool channel is unavailable"
+						}
+					};
+				}
+				for (const participant of [previous, candidate]) {
+					if (participant.kind !== "cli") continue;
+					const family = this.ctx.get("localAgent");
+					if (participant.childSessionId === void 0 || family?.memberConfiguration === void 0) return {
+						ok: false,
+						error: {
+							code: "coordinator-not-ready",
+							message: "Member native session preparation is required before promotion"
+						}
+					};
+					const inbox = family.isPreparedMember?.(participant.childSessionId) === true ? void 0 : family.readMemberInbox?.(participant.childSessionId);
+					if ((family.queuedMemberRounds?.(participant.childSessionId) ?? 0) > 0 || inbox?.messages.some((row) => [
+						"queued",
+						"running",
+						"uncertain"
+					].includes(row.status))) return {
+						ok: false,
+						error: { code: "coordinator-busy" }
+					};
+					const control = family.memberConfiguration(participant.childSessionId);
+					if (control.status !== "idle" || control.round !== void 0 || control.pending !== void 0 || control.lockedReason !== void 0) return {
+						ok: false,
+						error: {
+							code: "coordinator-not-ready",
+							message: "Member configuration has not converged or is locked"
+						}
+					};
+				}
+				const handoff = [
+					`Coordinator handoff from ${previous.name} to ${candidate.name}.`,
+					`Room session: ${request.sessionId}. Earlier native conversations remain available by their session IDs.`,
+					loaded.state.goal === void 0 ? "" : `Goal: ${loaded.state.goal}`,
+					loaded.state.plan === void 0 ? "" : `Formal goal ${loaded.state.plan.id}, revision ${loaded.state.plan.revision}: ${loaded.state.plan.objective} (${loaded.state.plan.status}). Read room_read for attempts, evidence, dependencies and budget; preserve the current pause state.`,
+					...loaded.state.tasks.filter((task) => !["done", "cancelled"].includes(task.status)).map((task) => `Open task ${task.id}: ${task.member}: ${task.title} (${task.status})`),
+					...events.filter((event) => event.type === "room/speech" || event.type === "room/dispatch").slice(-12).map((event) => event.type === "room/speech" ? `${event.data.member}: ${event.data.text.slice(0, 1500)}` : event.type === "room/dispatch" ? `To ${event.data.targets.join(", ")}: ${event.data.text.slice(0, 1500)}` : "")
+				].filter(Boolean).join("\n").slice(0, 16e3);
+				const value = {
+					version: 1,
+					memberId: request.memberId,
+					previousMemberId: memberId(events, previous),
+					revision: request.expectedRevision + 1,
+					handoff
+				};
+				loaded.session.append("room/coordinator", value);
+				await this.ctx.sessions.flush(loaded.session);
+				return {
+					ok: true,
+					value
+				};
+			} catch (error) {
+				return {
+					ok: false,
+					error: {
+						code: "coordinator-not-ready",
+						message: String(error)
+					}
+				};
+			} finally {
+				this.handoffs.delete(request.sessionId);
+			}
+		}
+		/**
+		* Remove a member from the roster. An in-flight run is NOT interrupted
+		* here — cancel() first when the member is running.
+		* @param request - room session, member name.
+		* @returns the removal receipt, or a rejection.
+		*/
+		async removeMember(request) {
+			const loaded = await this.ensureLive(request.sessionId);
+			if (!loaded.ok) return {
+				ok: false,
+				error: loaded.error
+			};
+			if (this.handoffs.has(request.sessionId)) return {
+				ok: false,
+				error: { code: "coordinator-busy" }
+			};
+			if (!loaded.state.members.some((member) => member.name === request.name)) return {
+				ok: false,
+				error: { code: "member-not-found" }
+			};
+			if (coordinatorMember(loaded.state, loaded.session.snapshotEvents())?.name === request.name) return {
+				ok: false,
+				error: { code: "active-coordinator" }
+			};
+			if (loaded.state.members.find((member) => member.name === request.name)?.kind === "main-agent") return {
+				ok: false,
+				error: { code: "main-member" }
+			};
+			loaded.session.append("room/member-removed", { name: request.name });
+			await this.ctx.sessions.flush(loaded.session);
+			return {
+				ok: true,
+				value: { name: request.name }
+			};
+		}
+		/**
+		* Post a human @-message into the room: leading `@name` tokens address
+		* members, and so does the request's `targets` list (the composer's
+		* mention-menu picks — explicit addressing wherever the `@name` sits); the
+		* two union before the roster check (a `room/dispatch` journal record,
+		* executed by the engine, and one auto-opened in_progress task per target).
+		* The human's raw text is
+		* FIRST appended as a standard `user/message` (source kind 'user' — the
+		* human typed it; the official messageDefinition classifies any other kind
+		* as a collapsed context-injection row, not the user bubble), so the words
+		* render as the official user bubble and enter the main agent's
+		* model-visible history. The append wakes nothing: turns start from
+		* prompt/followup calls, never from log appends (the agent is the log's
+		* writer, not a watcher). The `room/dispatch` record stays as pure
+		* bookkeeping (task board, dispatch cursors, replay) — it no longer drives
+		* any chat node. A BARE message is a structured `no-targets` rejection —
+		* defense only: the room composer releases bare messages to the official
+		* submit path (a normal main-agent turn) and never calls this Remote
+		* without addressing.
+		* @param request - room session, raw composer text, and the menu-picked addressees.
+		* @returns the parse receipt, or a rejection.
+		*/
+		async postMessage(request) {
+			const loaded = await this.ensureLive(request.sessionId);
+			if (!loaded.ok) return {
+				ok: false,
+				error: loaded.error
+			};
+			if (request.text.trim() === "") return {
+				ok: false,
+				error: { code: "empty-text" }
+			};
+			const requestSignature = createHash("sha256").update(JSON.stringify({
+				text: request.text.trim(),
+				targets: [...new Set(request.targets ?? [])].sort()
+			})).digest("hex");
+			if (request.requestId !== void 0) {
+				if (request.requestId.trim() === "" || request.requestId.length > 128) return {
+					ok: false,
+					error: { code: "request-conflict" }
+				};
+				const previous = loaded.session.snapshotEvents().find((event) => event.type === "room/dispatch" && event.data.id === request.requestId);
+				if (previous?.type === "room/dispatch") {
+					const original = previous.data;
+					const parsedRetry = parseMentions(request.text);
+					const retryTargets = [.../* @__PURE__ */ new Set([...parsedRetry.targets, ...request.targets ?? []])].sort();
+					const legacyMatch = original.origin === "human" && original.text === (parsedRetry.targets.length > 0 ? parsedRetry.text : request.text.trim()) && (retryTargets.length === 0 || JSON.stringify(retryTargets) === JSON.stringify([...original.targets].sort()));
+					if (original.requestSignature === void 0 ? !legacyMatch : original.requestSignature !== requestSignature) return {
+						ok: false,
+						error: { code: "request-conflict" }
+					};
+					await this.ctx.sessions.flush(loaded.session);
+					for (const target of original.targetIds ?? []) {
+						const member = replay(loaded.session.snapshotEvents()).members.find((member) => memberId(loaded.session.snapshotEvents(), member) === target);
+						if (member !== void 0) this.engine.dispatch(loaded.session, member.name, original.text, {
+							dispatchSeq: previous.seq,
+							targetId: target
+						});
+					}
+					return {
+						ok: true,
+						value: {
+							parsed: {
+								targets: original.targets,
+								text: original.text
+							},
+							seq: previous.seq
+						}
+					};
+				}
+			}
+			const parsed = parseMentions(request.text);
+			const targets = [.../* @__PURE__ */ new Set([...parsed.targets, ...request.targets ?? []])];
+			if (this.handoffs.has(request.sessionId)) return {
+				ok: false,
+				error: { code: "coordinator-busy" }
+			};
+			if (targets.length === 0) {
+				const selected = coordinatorMember(loaded.state, loaded.session.snapshotEvents());
+				if (selected === void 0) return {
+					ok: false,
+					error: { code: "member-not-found" }
+				};
+				targets.push(selected.name);
+			}
+			const text = parsed.targets.length > 0 ? parsed.text : request.text.trim();
+			if (text === "") return {
+				ok: false,
+				error: { code: "empty-text" }
+			};
+			const roster = new Set(loaded.state.members.map((member) => member.name));
+			const unknown = targets.filter((target) => !roster.has(target));
+			if (unknown.length > 0) return {
+				ok: false,
+				error: {
+					code: "unknown-targets",
+					names: unknown
+				}
+			};
+			loaded.session.append("user/message", createUserMessage({
+				content: [{
+					type: "text",
+					text: request.text.trim()
+				}],
+				source: { kind: "user" }
+			}), { surfaceOp: "append" });
+			const dispatch = loaded.session.append("room/dispatch", {
+				id: request.requestId ?? randomUUID(),
+				requestSignature,
+				targets,
+				text,
+				origin: "human",
+				targetIds: targets.map((name) => memberId(loaded.session.snapshotEvents(), loaded.state.members.find((member) => member.name === name)))
+			});
+			for (const target of targets) loaded.session.append("room/task-added", {
+				id: randomUUID(),
+				member: target,
+				title: taskTitle(text),
+				status: "in_progress",
+				deliveryId: `${dispatch.seq}:${memberId(loaded.session.snapshotEvents(), loaded.state.members.find((member) => member.name === target))}`
+			});
+			await this.ctx.sessions.flush(loaded.session);
+			for (const target of targets) this.engine.dispatch(loaded.session, target, text, { dispatchSeq: dispatch.seq });
+			return {
+				ok: true,
+				value: {
+					parsed: {
+						targets,
+						text
+					},
+					seq: dispatch.seq
+				}
+			};
+		}
+		/**
+		* Dispatch one message to one member (host-only — the `room_message` tool's
+		* path; the model-facing equivalent of the human's `@member text`). Same
+		* dispatch internals as postMessage minus the user/message bubble: the
+		* caller is the room's own main agent, so the text must NOT wear the human
+		* bubble (source kind 'user' would misattribute it). The dispatch record
+		* and the auto-opened in_progress task journal as usual.
+		* @param request - room session, addressee, text.
+		* @returns the dispatch receipt, or a rejection.
+		*/
+		async messageMember(request, actorChildSessionId) {
+			const loaded = await this.ensureRoom(request.sessionId);
+			if (!loaded.ok) return {
+				ok: false,
+				error: loaded.error
+			};
+			if (!this.isCurrentCoordinator(loaded.session, actorChildSessionId)) return {
+				ok: false,
+				error: { code: "not-coordinator" }
+			};
+			if (this.handoffs.has(request.sessionId)) return {
+				ok: false,
+				error: { code: "coordinator-busy" }
+			};
+			if (!loaded.state.members.some((member) => member.name === request.member)) return {
+				ok: false,
+				error: { code: "member-not-found" }
+			};
+			const text = request.text.trim();
+			if (text === "") return {
+				ok: false,
+				error: { code: "empty-text" }
+			};
+			const coordinator = coordinatorMember(loaded.state, loaded.session.snapshotEvents());
+			const target = loaded.state.members.find((member) => member.name === request.member);
+			const dispatch = loaded.session.append("room/dispatch", {
+				id: randomUUID(),
+				targets: [request.member],
+				targetIds: [memberId(loaded.session.snapshotEvents(), target)],
+				text,
+				origin: "coordinator",
+				...coordinator === void 0 || coordinator.name === request.member ? {} : { replyTo: memberId(loaded.session.snapshotEvents(), coordinator) }
+			});
+			loaded.session.append("room/task-added", {
+				id: randomUUID(),
+				member: request.member,
+				title: taskTitle(text),
+				status: "in_progress",
+				deliveryId: `${dispatch.seq}:${memberId(loaded.session.snapshotEvents(), target)}`
+			});
+			await this.ctx.sessions.flush(loaded.session);
+			this.engine.dispatch(loaded.session, request.member, text, { dispatchSeq: dispatch.seq });
+			return {
+				ok: true,
+				value: { member: request.member }
+			};
+		}
+		/** Host-authenticated actor; model tool arguments never provide the room or sender. */
+		isCurrentCoordinator(session, actorChildSessionId) {
+			const events = session.snapshotEvents();
+			const coordinator = coordinatorMember(replay(events), events);
+			return actorChildSessionId === void 0 ? coordinator?.kind === "main-agent" : coordinator?.childSessionId === actorChildSessionId;
+		}
+		/** Bounded shared room context for native and external model tools; reading never wakes an agent. */
+		async readRoomContext(sessionId) {
+			const state = await this.getState({ sessionId: SessionId(sessionId) });
+			if (!state.ok) throw new Error(`Room unavailable: ${state.error.code}`);
+			const recent = (this.ctx.sessions.get(SessionId(sessionId))?.snapshotEvents() ?? []).filter((event) => event.type === "room/speech").slice(-12).map((event) => event.type === "room/speech" ? {
+				member: event.data.member,
+				text: event.data.text.slice(0, 2e3)
+			} : null);
+			return JSON.stringify({
+				planCommands: planCommandContract(),
+				coordinator: coordinatorMember(state.value)?.name,
+				state: {
+					...state.value,
+					deliveries: state.value.deliveries?.slice(-30),
+					tasks: state.value.tasks.slice(-100),
+					relays: state.value.relays.slice(-30)
+				},
+				providers: await this.listProviders({}),
+				recent
+			});
+		}
+		/** Human UI and native/external tools share the same durable transition service. */
+		async planCommand(request) {
+			try {
+				const loaded = await this.ensureLive(request.sessionId);
+				if (!loaded.ok) return {
+					ok: false,
+					message: loaded.error.code
+				};
+				if (this.handoffs.has(request.sessionId)) return {
+					ok: false,
+					message: "Coordinator handoff is in progress"
+				};
+				await this.plans.command(loaded.session, request.command, {
+					kind: "human",
+					memberId: "human"
+				});
+				return { ok: true };
+			} catch (error) {
+				return {
+					ok: false,
+					message: String(error)
+				};
+			}
+		}
+		/** The actor is derived from the calling native agent or authenticated bridge. */
+		async commandPlan(sessionId, command, actorChildSessionId) {
+			const loaded = await this.ensureLive(SessionId(sessionId));
+			if (!loaded.ok) throw new Error(loaded.error.code);
+			if (this.handoffs.has(sessionId)) throw new Error("Coordinator handoff is in progress");
+			const events = loaded.session.snapshotEvents();
+			const state = replay(events);
+			const member = state.members.find((member) => actorChildSessionId === void 0 ? member.kind === "main-agent" : member.childSessionId === actorChildSessionId);
+			if (member === void 0) throw new Error("Calling member is not in this room");
+			const id = memberId(events, member);
+			const { requests: _requests, ...view } = await this.plans.command(loaded.session, command, {
+				kind: coordinatorMember(state, events)?.name === member.name ? "coordinator" : "worker",
+				memberId: id
+			});
+			return JSON.stringify(view);
+		}
+		/** Shared backend for external MCP room tools. Not exposed as a browser Remote. */
+		async receiveMemberCommand(actor, command) {
+			try {
+				const loaded = await this.ensureLive(SessionId(actor.parentSessionId));
+				if (!loaded.ok) return {
+					ok: false,
+					error: `Room unavailable: ${loaded.error.code}`
+				};
+				const sender = loaded.state.members.find((member) => member.childSessionId === actor.childSessionId && member.provider === actor.provider);
+				if (sender === void 0) return {
+					ok: false,
+					error: "The authenticated member is not in this room roster"
+				};
+				if (command === null || typeof command !== "object" || command.arguments === null || typeof command.arguments !== "object" || Array.isArray(command.arguments)) return {
+					ok: false,
+					error: "Malformed room command"
+				};
+				const args = command.arguments;
+				const keys = {
+					room_plan: ["command"],
+					room_read: [],
+					room_invite: [
+						"provider",
+						"name",
+						"instructions",
+						"cwd",
+						"model",
+						"firstTask"
+					],
+					room_message: ["member", "text"]
+				}[command.name];
+				if (keys === void 0 || Object.keys(args).some((key) => !keys.includes(key))) return {
+					ok: false,
+					error: "Unknown room command or argument; room and actor identity are host-owned"
+				};
+				const required = (key) => {
+					const value = args[key];
+					if (typeof value !== "string" || value.trim() === "") throw new Error(`A non-empty ${key} is required`);
+					return value;
+				};
+				const optional = (key) => args[key] === void 0 ? void 0 : required(key);
+				if (command.name === "room_read") return {
+					ok: true,
+					receipt: JSON.stringify({
+						self: sender.name,
+						...JSON.parse(await this.readRoomContext(loaded.session.id))
+					})
+				};
+				if (command.name === "room_plan") return {
+					ok: true,
+					receipt: await this.commandPlan(loaded.session.id, required("command"), actor.childSessionId)
+				};
+				if (!this.isCurrentCoordinator(loaded.session, actor.childSessionId)) return {
+					ok: false,
+					error: "Only the current coordinator may invite members or dispatch work"
+				};
+				const result = command.name === "room_invite" ? await this.inviteMember({
+					sessionId: loaded.session.id,
+					provider: required("provider"),
+					name: required("name"),
+					...optional("instructions") === void 0 ? {} : { instructions: optional("instructions") },
+					...optional("cwd") === void 0 ? {} : { cwd: optional("cwd") },
+					...optional("model") === void 0 ? {} : { model: optional("model") },
+					...optional("firstTask") === void 0 ? {} : { firstTask: optional("firstTask") }
+				}, "agent", actor.childSessionId) : await this.messageMember({
+					sessionId: loaded.session.id,
+					member: required("member"),
+					text: required("text")
+				}, actor.childSessionId);
+				return result.ok ? {
+					ok: true,
+					receipt: JSON.stringify(result.value)
+				} : {
+					ok: false,
+					error: result.error.code
+				};
+			} catch (error) {
+				return {
+					ok: false,
+					error: String(error)
+				};
+			}
+		}
+		/**
+		* The notification gate entry, verbatim-frozen contract for the local-agent
+		* family bridge (`ctx.get('room')` + duck-typed call). The call crosses an
+		* untyped package boundary, so the message shape is validated at runtime:
+		* a malformed message throws (the bridge treats a rejection as "room does
+		* not claim this" and delivers directly) instead of poisoning the journal.
+		* `from`/`to` arrive as roster names OR member child session ids (the
+		* bridge cannot speak names for the sender — only room owns the roster);
+		* both are normalized to roster names when resolvable, so the pending card
+		* and the delivery text (`{from} 给你的通知: …`) read as names. Phase 1's
+		* gate is ALWAYS human confirmation: the relay is journaled pending and
+		* the sender receives 'pending-confirm' (never 'sent' — the bridge keeps
+		* the member's conclusion honest). A non-room parent session throws.
+		* @param request - sender, recipient, content, the shared parent session, provenance.
+		* @returns the gate receipt.
+		*/
+		async receiveMemberMessage(request) {
+			if (typeof request?.from !== "string" || typeof request.to !== "string" || typeof request.content !== "string" || typeof request.parentSessionId !== "string") throw new Error("room: malformed member message (from/to/content/parentSessionId must be strings)");
+			const loaded = await this.ensureLive(request.parentSessionId);
+			if (!loaded.ok) throw new Error(`room: not a room session (${loaded.error.code})`);
+			if (loaded.state.members.find((member) => member.childSessionId === request.from && member.provider === request.provenance?.provider) !== void 0 && this.isCurrentCoordinator(loaded.session, request.from)) {
+				const target = loaded.state.members.find((member) => member.name === request.to || member.childSessionId === request.to);
+				if (target === void 0) throw new Error("Unknown room member");
+				const result = await this.messageMember({
+					sessionId: loaded.session.id,
+					member: target.name,
+					text: request.content
+				}, request.from);
+				if (!result.ok) throw new Error(result.error.code);
+				return "sent";
+			}
+			const resolveName = (endpoint) => {
+				const byName = loaded.state.members.find((member) => member.name === endpoint);
+				if (byName !== void 0) return byName.name;
+				return loaded.state.members.find((member) => member.childSessionId === endpoint)?.name ?? endpoint;
+			};
+			loaded.session.append("room/relay", {
+				id: randomUUID(),
+				from: resolveName(request.from),
+				to: resolveName(request.to),
+				content: request.content,
+				...request.provenance === void 0 ? {} : { provenance: request.provenance }
+			});
+			await this.ctx.sessions.flush(loaded.session);
+			return "pending-confirm";
+		}
+		/**
+		* Confirm a pending relay: journal the confirmed edge and dispatch the
+		* notification to the recipient as a continuation (`{from} 给你的通知:
+		* {content}`); the engine marks the relay sent once the recipient's own
+		* session receives the prompt.
+		* @param request - room session, relay id.
+		* @returns the resolution receipt, or a rejection.
+		*/
+		async confirmRelay(request) {
+			const loaded = await this.ensureLive(request.sessionId);
+			if (!loaded.ok) return {
+				ok: false,
+				error: loaded.error
+			};
+			const relay = loaded.state.relays.find((entry) => entry.id === request.relayId);
+			if (relay === void 0) return {
+				ok: false,
+				error: { code: "relay-not-found" }
+			};
+			if (relay.state !== "pending") return {
+				ok: false,
+				error: { code: "relay-not-pending" }
+			};
+			if (!loaded.state.members.some((member) => member.name === relay.to)) return {
+				ok: false,
+				error: { code: "member-not-found" }
+			};
+			loaded.session.append("room/relay-resolved", {
+				id: relay.id,
+				state: "confirmed"
+			});
+			await this.ctx.sessions.flush(loaded.session);
+			this.engine.dispatch(loaded.session, relay.to, `${relay.from} 给你的通知: ${relay.content}`, { relayIds: [relay.id] });
+			return {
+				ok: true,
+				value: { relayId: relay.id }
+			};
+		}
+		/**
+		* Dismiss a pending relay: the notification never reaches anyone.
+		* @param request - room session, relay id.
+		* @returns the resolution receipt, or a rejection.
+		*/
+		async dismissRelay(request) {
+			const loaded = await this.ensureLive(request.sessionId);
+			if (!loaded.ok) return {
+				ok: false,
+				error: loaded.error
+			};
+			const relay = loaded.state.relays.find((entry) => entry.id === request.relayId);
+			if (relay === void 0) return {
+				ok: false,
+				error: { code: "relay-not-found" }
+			};
+			if (relay.state !== "pending") return {
+				ok: false,
+				error: { code: "relay-not-pending" }
+			};
+			loaded.session.append("room/relay-resolved", {
+				id: relay.id,
+				state: "dismissed"
+			});
+			await this.ctx.sessions.flush(loaded.session);
+			return {
+				ok: true,
+				value: { relayId: relay.id }
+			};
+		}
+		/**
+		* Add a task to a member's board lane (the human's management entry; @-
+		* dispatches auto-open in_progress tasks, this opens a pending one).
+		* `blockedBy` names the member the task waits on (display only — it never
+		* dispatches anything); it must resolve against the roster.
+		* @param request - room session, member, title, optional blockedBy.
+		* @returns the new task's id, or a rejection.
+		*/
+		async addTask(request) {
+			const loaded = await this.ensureLive(request.sessionId);
+			if (!loaded.ok) return {
+				ok: false,
+				error: loaded.error
+			};
+			if (!loaded.state.members.some((member) => member.name === request.member)) return {
+				ok: false,
+				error: { code: "member-not-found" }
+			};
+			if (request.title.trim() === "") return {
+				ok: false,
+				error: { code: "empty-text" }
+			};
+			if (request.blockedBy !== void 0 && !loaded.state.members.some((member) => member.name === request.blockedBy)) return {
+				ok: false,
+				error: { code: "member-not-found" }
+			};
+			const id = randomUUID();
+			loaded.session.append("room/task-added", {
+				id,
+				member: request.member,
+				title: request.title.trim(),
+				status: "pending",
+				...request.blockedBy === void 0 ? {} : { blockedBy: request.blockedBy }
+			});
+			await this.ctx.sessions.flush(loaded.session);
+			return {
+				ok: true,
+				value: { id }
+			};
+		}
+		/**
+		* Close an open task (done by default, or cancelled). A failed task is
+		* still open for closing — that is the human's dismiss path after a
+		* failed run (the board's [关闭] passes 'cancelled').
+		* @param request - room session, task id, optional closing status.
+		* @returns the closed task's id, or a rejection.
+		*/
+		async closeTask(request) {
+			const loaded = await this.ensureLive(request.sessionId);
+			if (!loaded.ok) return {
+				ok: false,
+				error: loaded.error
+			};
+			const task = loaded.state.tasks.find((entry) => entry.id === request.taskId);
+			if (task === void 0) return {
+				ok: false,
+				error: { code: "task-not-found" }
+			};
+			if (task.status === "done" || task.status === "cancelled") return {
+				ok: false,
+				error: { code: "task-closed" }
+			};
+			loaded.session.append("room/task-updated", {
+				id: task.id,
+				status: request.status ?? "done"
+			});
+			await this.ctx.sessions.flush(loaded.session);
+			return {
+				ok: true,
+				value: { id: task.id }
+			};
+		}
+		/**
+		* Edit an open task's title and/or blockedBy (the `room_task` tool's update
+		* action; journaled as `room/task-edited`, status changes stay on
+		* closeTask). Host method only — the capsule UI edits nothing but the goal.
+		* `blockedBy: null` clears the wait; a string must resolve against the
+		* roster. A closed task takes no edits.
+		* @param request - room session, task id, and at least one edited field.
+		* @returns the edited task's id, or a rejection.
+		*/
+		async updateTask(request) {
+			const loaded = await this.ensureLive(request.sessionId);
+			if (!loaded.ok) return {
+				ok: false,
+				error: loaded.error
+			};
+			const task = loaded.state.tasks.find((entry) => entry.id === request.taskId);
+			if (task === void 0) return {
+				ok: false,
+				error: { code: "task-not-found" }
+			};
+			if (task.status === "done" || task.status === "cancelled") return {
+				ok: false,
+				error: { code: "task-closed" }
+			};
+			if (request.title === void 0 && request.blockedBy === void 0) return {
+				ok: false,
+				error: { code: "nothing-to-update" }
+			};
+			if (request.title !== void 0 && request.title.trim() === "") return {
+				ok: false,
+				error: { code: "empty-text" }
+			};
+			if (typeof request.blockedBy === "string" && !loaded.state.members.some((member) => member.name === request.blockedBy)) return {
+				ok: false,
+				error: { code: "member-not-found" }
+			};
+			loaded.session.append("room/task-edited", {
+				id: task.id,
+				...request.title === void 0 ? {} : { title: request.title.trim() },
+				...request.blockedBy === void 0 ? {} : { blockedBy: request.blockedBy }
+			});
+			await this.ctx.sessions.flush(loaded.session);
+			return {
+				ok: true,
+				value: { id: task.id }
+			};
+		}
+		/**
+		* Set (or, with a blank text, clear) the room's goal. The goal is one
+		* journaled line — the latest `room/goal` event wins; it rides the top of
+		* the roster section in every member prompt and drives the dock's goal
+		* capsule. Pure display/coordination text: it never dispatches anything.
+		* @param request - room session and goal text.
+		* @returns the now-current goal (absent after a clear), or a rejection.
+		*/
+		async setGoal(request) {
+			const loaded = await this.ensureLive(request.sessionId);
+			if (!loaded.ok) return {
+				ok: false,
+				error: loaded.error
+			};
+			const text = request.text.trim();
+			loaded.session.append("room/goal", { text });
+			await this.ctx.sessions.flush(loaded.session);
+			return {
+				ok: true,
+				value: text === "" ? {} : { goal: text }
+			};
+		}
+		/**
+		* Cancel a member's in-flight run through the local-agent facade. A hit
+		* journals the terminal `cancelled` edge immediately (the engine's own
+		* settle for that run then no-ops); a miss — no facade, no delegation
+		* handle, or nothing in flight — journals nothing and reports
+		* `cancelled: false`.
+		* @param request - room session, member name.
+		* @returns the cancellation receipt, or a rejection.
+		*/
+		async cancel(request) {
+			const loaded = await this.ensureLive(request.sessionId);
+			if (!loaded.ok) return {
+				ok: false,
+				error: loaded.error
+			};
+			const member = loaded.state.members.find((entry) => entry.name === request.name);
+			if (member === void 0) return {
+				ok: false,
+				error: { code: "member-not-found" }
+			};
+			const facade = probeLocalAgent(this.ctx);
+			if (facade !== void 0 && member.childSessionId !== void 0 ? facade.cancel(member.childSessionId) : false) {
+				const running = loaded.state.runs.find((entry) => entry.member === request.name && entry.state === "running");
+				if (running === void 0) return {
+					ok: true,
+					value: { cancelled: true }
+				};
+				loaded.session.append("room/run-state", {
+					member: request.name,
+					state: "cancelled",
+					startedAt: running.startedAt,
+					...running.runId === void 0 ? {} : { runId: running.runId }
+				});
+				for (const task of loaded.state.tasks) if (task.member === request.name && task.status === "in_progress" && (running.runId === void 0 || task.deliveryId === running.runId)) loaded.session.append("room/task-updated", {
+					id: task.id,
+					status: "cancelled"
+				});
+				await this.ctx.sessions.flush(loaded.session);
+				return {
+					ok: true,
+					value: { cancelled: true }
+				};
+			}
+			return {
+				ok: true,
+				value: { cancelled: false }
+			};
+		}
+	};
+})();
+//#endregion
+export { MAIN_AGENT_MEMBER, ROOM_EVENT_TYPES, RoomService, RoomService as default };