openmeld 0.3.222 → 0.3.224

package/dist/{runtime-reporting-health-state-BgwfrH7f.js → runtime-reporting-health-state-DA-_vW-n.js}

@@ -1,28 +1,35 @@
 #!/usr/bin/env node
 
 import { g as toSpaceUpdatesUrl } from "./urls-CY2uzH2-.js";
-import { A as OPENMELD_HOME_ENV_KEY, lt as resolveOpenMeldRootDir, nt as organizationSkillReleaseDir, s as releaseLock, t as acquireLock } from "./lock-Bsl_ElWy.js";
-import { $n as getSpaceUpdatesResponseSchema, Lr as stringifyOrganizationSkillBundleCanonicalJson, Pr as organizationSkillBundleSchema, Xn as OPENMELD_HEADER_SPACE_ADDRESSING_VERSION, an as createRuntimeReportingApi, jt as createAgentActivityApi, qr as submitAgentControllerTaskLifecycleEventItemSchema, ri as observedLocalAgentSessionSchema, t as OpenMeldApiClientHttpError } from "./dist-B07ziN_u.js";
-import { Jn as buildCliLaunchInvocation, Tt as withAgentActivityLocalStateLock, _n as resolveInstalledGrokBuildLaunchCandidates, bn as resolveInstalledCodexLaunchCandidates, ft as listProjectBindings, ht as removeAgentActivityBindingsWhileDeliveryLocked, mn as resolveInstalledOpenCodeLaunchCandidates, vt as resolveProjectBindingForPath, wn as resolveInstalledClaudeCodeLaunchCandidates, wt as withAgentActivityDeliveryLock } from "./prepare-provider-runtime-CWZcuMF6.js";
-import { Ut as spaceWorkRelativePathSchema, Vt as SPACE_WORK_MAX_BYTES, Wt as spaceWorkSelectionSchema } from "./runtime-transport-Cc_RN-PL.js";
-import { d as getAuthSessionState } from "./auth-session-nhS8jyux.js";
-import { o as dirnamePath } from "./daemon-device-id-DWO9_QW6.js";
-import { C as readAgentActivityOutboxHealth, E as readRecentAgentActivityHookStatus, S as deferAgentActivityOutbox, T as removeProjectOutbox, _ as drainAgentActivityHookInbox, b as AgentActivitySubmissionResultsMismatchError, c as scanLocalAgentActivity, f as resolveOpenCodeDatabasePath, h as normalizeSharedSessionTitle, l as startAgentActivityTranscriptWatchers, m as resolveObservedAgentActivityBinding, u as readOpenCodeSessionRows, w as readDueAgentActivityOutbox, x as applyAgentActivitySubmissionResults, y as removeProjectInbox } from "./daemon-frame-transport-D2-tazuK.js";
+import { A as OPENMELD_HOME_ENV_KEY, d as runWithHeldLock, rt as organizationSkillReleaseDir, s as releaseLock, t as acquireLock, ut as resolveOpenMeldRootDir } from "./lock-iue1J2xy.js";
+import { Lr as stringifyOrganizationSkillBundleCanonicalJson, Mt as createAgentActivityApi, Pr as organizationSkillBundleSchema, Ti as signalTextEnvelopeSchema, Zn as OPENMELD_HEADER_SPACE_ADDRESSING_VERSION, _r as spaceTaskMutationReceiptSchema, er as getSpaceUpdatesResponseSchema, gr as spaceTaskIdSchema, hr as mutateSpaceTaskBodySchema, mr as createSpaceTaskBodySchema, on as createRuntimeReportingApi, qr as submitAgentControllerTaskLifecycleEventItemSchema, ri as observedLocalAgentSessionSchema, t as OpenMeldApiClientHttpError } from "./dist-BeJcIdCZ.js";
+import { Jn as buildCliLaunchInvocation, Tt as withAgentActivityLocalStateLock, Xn as resolveExecutablePathsOnPath, Zn as listAgentControllerSupervisedProcessIds, _n as resolveInstalledGrokBuildLaunchCandidates, bn as resolveInstalledCodexLaunchCandidates, er as isDispatchSpaceActionDeliveryOnly, ft as listProjectBindings, ht as removeAgentActivityBindingsWhileDeliveryLocked, mn as resolveInstalledOpenCodeLaunchCandidates, qn as resolveDispatchSpaceActionMcpServer, vt as resolveProjectBindingForPath, wn as resolveInstalledClaudeCodeLaunchCandidates, wt as withAgentActivityDeliveryLock } from "./prepare-provider-runtime-MB-BxOgt.js";
+import { Gt as spaceWorkSelectionSchema, Ht as SPACE_WORK_MAX_BYTES, Kt as spaceWorkingCopyResultSchema, Wt as spaceWorkRelativePathSchema, Yn as executionContextAssignmentSchema, Zn as executionContextTaskSchema, _n as spaceMessageFileReferenceSchema, fn as spaceFileEntryIdSchema, gn as spaceFileRevisionNumberSchema, rn as readSpaceFileTextResponseSchema } from "./runtime-transport-YIYHSJPn.js";
+import { d as getAuthSessionState } from "./auth-session-uEk_Tx6T.js";
+import { O as openMeldRuntimeProfileIdSchema } from "./control-plane-rTE2rHZ5.js";
+import { C as readAgentActivityOutboxHealth, E as readRecentAgentActivityHookStatus, S as deferAgentActivityOutbox, T as removeProjectOutbox, _ as drainAgentActivityHookInbox, b as AgentActivitySubmissionResultsMismatchError, bn as cliJsonErrorEnvelopeSchema, c as scanLocalAgentActivity, f as resolveOpenCodeDatabasePath, h as normalizeSharedSessionTitle, l as startAgentActivityTranscriptWatchers, m as resolveObservedAgentActivityBinding, u as readOpenCodeSessionRows, w as readDueAgentActivityOutbox, x as applyAgentActivitySubmissionResults, y as removeProjectInbox } from "./daemon-frame-transport-WiB73yhT.js";
+import { B as requireOpenMeldProfile, o as dirnamePath } from "./daemon-device-id-B1Af2Zmn.js";
+import { a as resolveBaseUrl } from "./base-url-DvjOkKPs.js";
 import { n as writeDaemonLocalStateFile, t as readDaemonLocalStateFile } from "./daemon-local-state-file-jOXuXrky.js";
-import { _ as daemonRuntimeStateRootPath } from "./daemon-state-B44aq2nm.js";
-import { i as readDaemonServiceContract } from "./daemon-service-contract-BpOBMGX0.js";
-import { l as resolveUserFacingCliEntryCommand } from "./cli-entry-command-CR_9QU1i.js";
-import { l as canAttachAuthTokenToRequest, n as fetchSpaceRequestWithTimeout, s as buildOpenMeldRequestContextHeadersWithAuth, t as createCliApiClientFoundation } from "./api-client-foundation-DnJ_JYli.js";
-import { c as readGatewayTextResponse, u as parseJsonResponse } from "./cli-space-api-CQtKu9Zt.js";
-import { createHash, randomUUID } from "node:crypto";
+import { _ as daemonRuntimeStateRootPath } from "./daemon-state-Ca0WK5x0.js";
+import { i as readDaemonServiceContract } from "./daemon-service-contract-GLmAxsq-.js";
+import { l as resolveUserFacingCliEntryCommand, n as formatOpenMeldCliCommand } from "./cli-entry-command-CR_9QU1i.js";
+import { r as outLine } from "./io-DT66typ4.js";
+import { d as buildOpenMeldRequestContextFromProfile, l as canAttachAuthTokenToRequest, n as fetchSpaceRequestWithTimeout, s as buildOpenMeldRequestContextHeadersWithAuth, t as createCliApiClientFoundation } from "./api-client-foundation-DpVwrgh-.js";
+import { S as readDispatchSpaceActionRecord, _ as DispatchSpaceActionRejectedError, b as readDispatchSpaceActionContextForReceiptFromEnv, d as uploadPreparedSpaceFiles, f as createCliSpaceApi, g as DispatchSpaceActionClosedError, l as parseJsonResponse, s as readGatewayTextResponse, u as prepareRequestedSpaceSendFiles, w as writeDispatchSpaceActionRecord, x as readDispatchSpaceActionContextFromEnv } from "./meta-api-B1k3mwHN.js";
+import { createHash, randomBytes, randomUUID } from "node:crypto";
 import { homedir } from "node:os";
-import { basename, dirname, isAbsolute, join, resolve } from "node:path";
-import { appendFile, chmod, copyFile, lstat, mkdir, mkdtemp, open, readFile, readdir, realpath, rename, rm, stat, unlink, writeFile } from "node:fs/promises";
+import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { appendFile, chmod, copyFile, lstat, mkdir, mkdtemp, open, readFile, readdir, readlink, realpath, rename, rm, stat, unlink, writeFile } from "node:fs/promises";
 import * as z$1 from "zod/v4";
 import { z } from "zod/v4";
-import { constants, createReadStream } from "node:fs";
-import { spawn } from "node:child_process";
+import { constants, createReadStream, readFileSync } from "node:fs";
+import { execFile, spawn } from "node:child_process";
+import { promisify } from "node:util";
 import { createInterface } from "node:readline";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { performance } from "node:perf_hooks";
 //#region ../../packages/schemas/dist/schemas/config/agent-activity-route-registry.js
 const agentActivityRouteRegistrySchema = z$1.strictObject({
 	routes: z$1.array(z$1.strictObject({ rootDir: z$1.string().trim().min(1).max(4096) })).max(64),
@@ -74,6 +81,87 @@ const runtimeReportingHealthStateSchema = z$1.strictObject({
 	providerConversationProof: runtimeReportingChannelHealthSchema
 });
 //#endregion
+//#region ../../packages/schemas/dist/schemas/space-mesh/dispatch-project-shell.js
+const dispatchProjectShellInputSchema = z$1.strictObject({ command: z$1.string().trim().min(1).max(16e3) });
+const dispatchProjectShellResultSchema = z$1.strictObject({
+	exitCode: z$1.number().int().min(0).max(255),
+	stdout: z$1.string().max(128 * 1024),
+	stderr: z$1.string().max(128 * 1024)
+});
+//#endregion
+//#region ../../packages/schemas/dist/schemas/space-mesh/dispatch-space-action-receipt.js
+const dispatchSpaceActionClosedReasonCodeSchema = z$1.enum(["space_action.context_expired", "space_action.context_mismatch"]);
+const dispatchSpaceActionReceiptSchema = z$1.discriminatedUnion("status", [
+	z$1.strictObject({
+		status: z$1.literal("proposal_saved_locally"),
+		actionType: z$1.enum([
+			"post_message",
+			"post_status",
+			"stay_silent"
+		]),
+		attemptId: z$1.string().min(1),
+		contextId: z$1.string().min(1),
+		dispatchId: z$1.string().min(1),
+		recordedAtMs: z$1.number().int().nonnegative(),
+		contextState: z$1.enum(["active", "expired"]),
+		coordinatorAcceptance: z$1.literal("unconfirmed"),
+		publication: z$1.literal("unconfirmed")
+	}),
+	z$1.strictObject({
+		status: z$1.literal("rejected_closed"),
+		reasonCode: dispatchSpaceActionClosedReasonCodeSchema,
+		coordinatorAcceptance: z$1.literal("unconfirmed"),
+		publication: z$1.literal("unconfirmed")
+	}),
+	z$1.strictObject({
+		status: z$1.literal("rejected_before_recording"),
+		reasonCode: z$1.enum([
+			"space_action.invalid_input",
+			"space_action.not_allowed",
+			"space_action.already_recorded",
+			"space_action.targets_unavailable"
+		]),
+		coordinatorAcceptance: z$1.literal("unconfirmed"),
+		publication: z$1.literal("unconfirmed")
+	}),
+	z$1.strictObject({
+		status: z$1.literal("outcome_unknown"),
+		reasonCode: z$1.literal("space_action.recording_outcome_unknown"),
+		coordinatorAcceptance: z$1.literal("unconfirmed"),
+		publication: z$1.literal("unconfirmed")
+	})
+]);
+const dispatchSpaceActionToolResultSchema = z$1.strictObject({ receipt: dispatchSpaceActionReceiptSchema });
+//#endregion
+//#region ../../packages/schemas/dist/schemas/space-mesh/dispatch-space-history.js
+const dispatchSpaceHistoryRequestSchema = z$1.strictObject({});
+const dispatchSpaceHistoryResultSchema = z$1.strictObject({
+	spaceId: z$1.string().min(1),
+	sourceSignalId: z$1.string().min(1),
+	beforeCount: z$1.literal(20),
+	afterCount: z$1.literal(0),
+	signals: z$1.array(z$1.record(z$1.string(), z$1.unknown())).max(21),
+	nextCursor: z$1.string().min(1).nullable()
+});
+//#endregion
+//#region ../../packages/schemas/dist/schemas/space-mesh/dispatch-space-read-result.js
+const dispatchSpaceReadResultRequestSchema = z$1.strictObject({
+	resultId: z$1.string().uuid(),
+	offset: z$1.number().int().nonnegative()
+});
+/** A byte cursor addresses one immutable JSON snapshot, not a local file. */
+const dispatchSpaceReadResultPageSchema = z$1.strictObject({
+	resultId: z$1.string().uuid(),
+	offset: z$1.number().int().nonnegative(),
+	nextOffset: z$1.number().int().positive().nullable(),
+	totalBytes: z$1.number().int().positive(),
+	text: z$1.string()
+});
+const dispatchSpaceReadResultSchema = z$1.strictObject({
+	result: z$1.record(z$1.string(), z$1.unknown()).optional(),
+	page: dispatchSpaceReadResultPageSchema.optional()
+}).refine((value) => value.result !== void 0 !== (value.page !== void 0), { message: "A read returns either the complete result or one continuation page." });
+//#endregion
 //#region src/agent-activity/managed-integrations.ts
 const AGENT_ACTIVITY_INTEGRATION_OWNER = "openmeld-agent-activity-v1";
 const LEGACY_AGENT_ACTIVITY_INTEGRATION_OWNER = "openmeld-agent-activity-v0";
@@ -2783,6 +2871,2109 @@ async function readLocalReportingHealth(rootDir) {
 	return await Promise.all([readAgentActivityOutboxHealth({ rootDir }), readControllerTaskLifecycleOutboxHealth({ rootDir })]);
 }
 //#endregion
+//#region src/local-service/file-access/claude-project-container.ts
+const execFileAsync$2 = promisify(execFile);
+const PROJECT_IMAGE = "node:24-bookworm@sha256:64af3819f9275802414d7cdc38c27e9d82bd564dec4d4da87d008255d36c63b4";
+const WORKSPACE_IN_CONTAINER = "/workspace";
+const COMMAND_TIMEOUT_MS = 12e4;
+const COMMAND_OUTPUT_BYTES = 128 * 1024;
+const CONTAINER_NAME_PREFIX = "openmeld-claude-project-";
+const CONTAINER_MISSING_RE = /no such container|no container with name|does not exist/iu;
+const LINE_BREAK_RE = /\r?\n/u;
+const CONTEXT_ID_RE = /^[a-f0-9-]{36}$/iu;
+async function resolveClaudeProjectContainerRuntime() {
+	for (const kind of ["docker", "podman"]) {
+		const binary = resolveExecutablePathsOnPath(kind)[0];
+		if (!binary) continue;
+		try {
+			await execFileAsync$2(binary, [
+				"version",
+				"--format",
+				"{{.Server.Version}}"
+			], {
+				encoding: "utf8",
+				maxBuffer: 4096,
+				timeout: 5e3,
+				windowsHide: true
+			});
+			return {
+				binary,
+				engineIdentity: await readContainerEngineIdentity({
+					binary,
+					kind
+				}),
+				kind
+			};
+		} catch {}
+	}
+	throw new Error("claude_project.container_runtime_unavailable");
+}
+async function prepareClaudeProjectContainer(input) {
+	const runtime = await resolveClaudeProjectContainerRuntime();
+	try {
+		await execFileAsync$2(runtime.binary, [
+			"image",
+			"inspect",
+			"--format",
+			"{{.Id}}",
+			PROJECT_IMAGE
+		], {
+			encoding: "utf8",
+			maxBuffer: 4096,
+			timeout: 1e4,
+			windowsHide: true
+		});
+	} catch {
+		try {
+			await execFileAsync$2(runtime.binary, ["pull", PROJECT_IMAGE], {
+				encoding: "utf8",
+				maxBuffer: 1024 * 1024,
+				timeout: 3e5,
+				windowsHide: true
+			});
+		} catch (error) {
+			throw new Error("claude_project.image_unavailable", { cause: error });
+		}
+	}
+	const workspacePath = await realpath(input.workspacePath);
+	const boundaryRoot = await realpath(input.boundaryRoot);
+	if (workspacePath !== input.workspacePath || boundaryRoot !== input.boundaryRoot) throw new Error("claude_project.workspace_path_changed");
+	const relativeWorkspace = assertContainedWorkspace(boundaryRoot, workspacePath);
+	const outsideDirectory = await mkdtemp(join(dirname(boundaryRoot), ".openmeld-container-probe-"));
+	const marker = randomUUID();
+	const insideName = `.openmeld-container-probe-${marker}`;
+	const insidePath = join(workspacePath, insideName);
+	const outsidePath = join(outsideDirectory, "outside");
+	const writeName = `.openmeld-container-write-probe-${marker}`;
+	const writePath = join(workspacePath, writeName);
+	try {
+		await writeFile(insidePath, `inside:${marker}`, {
+			flag: "wx",
+			mode: 384
+		});
+		await writeFile(outsidePath, `outside:${marker}`, {
+			flag: "wx",
+			mode: 384
+		});
+		const inside = await runClaudeProjectContainerCommand({
+			command: `cat ${quoteShellArgument(`${WORKSPACE_IN_CONTAINER}/${relativeWorkspace}/${insideName}`)}`,
+			contextId: input.contextId,
+			runtime,
+			boundaryRoot,
+			workspacePath
+		});
+		if (inside.exitCode !== 0 || inside.stdout.trim() !== `inside:${marker}`) throw new Error("claude_project.inside_access_unverified");
+		const outside = await runClaudeProjectContainerCommand({
+			command: `cat ${quoteShellArgument(outsidePath)}`,
+			contextId: input.contextId,
+			runtime,
+			boundaryRoot,
+			workspacePath
+		});
+		if (outside.exitCode === 0 || outside.stdout.includes(`outside:${marker}`)) throw new Error("claude_project.outside_access_unverified");
+		if ((await runClaudeProjectContainerCommand({
+			command: `printf 'written:${marker}' > ${quoteShellArgument(`${WORKSPACE_IN_CONTAINER}/${relativeWorkspace}/${writeName}`)}`,
+			contextId: input.contextId,
+			runtime,
+			boundaryRoot,
+			workspacePath
+		})).exitCode !== 0 || await readFile(writePath, "utf8") !== `written:${marker}`) throw new Error("claude_project.inside_write_unverified");
+		return runtime;
+	} finally {
+		await rm(insidePath, { force: true });
+		await rm(writePath, { force: true });
+		await rm(outsideDirectory, {
+			recursive: true,
+			force: true
+		});
+	}
+}
+function quoteShellArgument(value) {
+	return `'${value.replaceAll("'", `'"'"'`)}'`;
+}
+async function runClaudeProjectContainerCommand(input) {
+	await assertContainerEngineIdentity(input.runtime);
+	const workspacePath = await realpath(input.workspacePath);
+	const boundaryRoot = await realpath(input.boundaryRoot);
+	if (workspacePath !== input.workspacePath || boundaryRoot !== input.boundaryRoot) throw new Error("claude_project.workspace_path_changed");
+	const relativeWorkspace = assertContainedWorkspace(boundaryRoot, workspacePath);
+	if (!isAbsolute(workspacePath) || boundaryRoot.includes(",") || boundaryRoot.includes("\n") || boundaryRoot.includes("\r")) throw new Error("claude_project.workspace_path_unsupported");
+	if (!input.command.trim() || input.command.length > 16e3) throw new Error("claude_project.command_invalid");
+	const name = `${containerNamePrefix(input.contextId)}${randomBytes(4).toString("hex")}`;
+	const args = buildClaudeProjectContainerArgs({
+		command: input.command,
+		name,
+		boundaryRoot,
+		relativeWorkspace
+	});
+	let outcome;
+	try {
+		const result = await execFileAsync$2(input.runtime.binary, args, {
+			encoding: "utf8",
+			maxBuffer: COMMAND_OUTPUT_BYTES,
+			timeout: 135e3,
+			windowsHide: true
+		});
+		outcome = {
+			exitCode: 0,
+			stdout: result.stdout,
+			stderr: result.stderr
+		};
+	} catch (error) {
+		const commandError = error;
+		if (typeof commandError.code === "number") outcome = {
+			exitCode: commandError.code,
+			stdout: commandError.stdout ?? "",
+			stderr: commandError.stderr ?? ""
+		};
+		else outcome = /* @__PURE__ */ new Error(`claude_project.container_command_failed: ${commandError.message}`);
+	}
+	try {
+		await execFileAsync$2(input.runtime.binary, [
+			"rm",
+			"-f",
+			name
+		], {
+			encoding: "utf8",
+			maxBuffer: 4096,
+			timeout: 15e3,
+			windowsHide: true
+		});
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		if (!CONTAINER_MISSING_RE.test(message)) throw new Error(`claude_project.container_cleanup_unconfirmed: ${message}`, { cause: outcome });
+	}
+	if (outcome instanceof Error) throw outcome;
+	return outcome;
+}
+async function stopClaudeProjectContainersForContext(input) {
+	await assertContainerEngineIdentity(input.runtime);
+	const prefix = containerNamePrefix(input.contextId);
+	let names;
+	try {
+		const { stdout } = await execFileAsync$2(input.runtime.binary, [
+			"ps",
+			"-a",
+			"--filter",
+			`name=${prefix}`,
+			"--format",
+			"{{.Names}}"
+		], {
+			encoding: "utf8",
+			maxBuffer: 16384,
+			timeout: 15e3,
+			windowsHide: true
+		});
+		names = stdout.split(LINE_BREAK_RE).filter((name) => name.startsWith(prefix));
+	} catch (error) {
+		throw new Error("claude_project.container_cleanup_unconfirmed", { cause: error });
+	}
+	for (const name of names) try {
+		await execFileAsync$2(input.runtime.binary, [
+			"rm",
+			"-f",
+			name
+		], {
+			encoding: "utf8",
+			maxBuffer: 4096,
+			timeout: 15e3,
+			windowsHide: true
+		});
+	} catch (error) {
+		throw new Error("claude_project.container_cleanup_unconfirmed", { cause: error });
+	}
+}
+async function assertContainerEngineIdentity(runtime) {
+	if (await readContainerEngineIdentity(runtime) !== runtime.engineIdentity) throw new Error("claude_project.container_engine_changed");
+}
+async function readContainerEngineIdentity(input) {
+	if (input.kind === "docker") {
+		const { stdout } = await execFileAsync$2(input.binary, [
+			"info",
+			"--format",
+			"{{.ID}}"
+		], {
+			encoding: "utf8",
+			maxBuffer: 4096,
+			timeout: 5e3,
+			windowsHide: true
+		});
+		const identity = stdout.trim();
+		if (!identity) throw new Error("claude_project.container_engine_identity_missing");
+		return identity;
+	}
+	const { stdout } = await execFileAsync$2(input.binary, [
+		"info",
+		"--format",
+		"json"
+	], {
+		encoding: "utf8",
+		maxBuffer: 128 * 1024,
+		timeout: 5e3,
+		windowsHide: true
+	});
+	const info = JSON.parse(stdout);
+	if (typeof info.host?.hostname !== "string" || typeof info.store?.graphRoot !== "string") throw new Error("claude_project.container_engine_identity_missing");
+	return `${info.host.hostname}:${info.store.graphRoot}`;
+}
+function containerNamePrefix(contextId) {
+	if (!CONTEXT_ID_RE.test(contextId)) throw new Error("claude_project.context_id_invalid");
+	return `${CONTAINER_NAME_PREFIX}${contextId.replaceAll("-", "")}-`;
+}
+function buildClaudeProjectContainerArgs(input) {
+	if (!input.name.startsWith(CONTAINER_NAME_PREFIX)) throw new Error("claude_project.container_name_invalid");
+	const user = typeof process.getuid === "function" && typeof process.getgid === "function" ? `${process.getuid()}:${process.getgid()}` : "1000:1000";
+	return [
+		"run",
+		"--rm",
+		"--pull",
+		"never",
+		"--name",
+		input.name,
+		"--network",
+		"none",
+		"--read-only",
+		"--cap-drop",
+		"ALL",
+		"--security-opt",
+		"no-new-privileges",
+		"--pids-limit",
+		"128",
+		"--memory",
+		"1g",
+		"--cpus",
+		"2",
+		"--user",
+		user,
+		"--mount",
+		`type=bind,src=${input.boundaryRoot},dst=${WORKSPACE_IN_CONTAINER}`,
+		"--workdir",
+		`${WORKSPACE_IN_CONTAINER}/${input.relativeWorkspace}`,
+		"--tmpfs",
+		"/tmp:rw,nosuid,nodev,size=64m",
+		"--env",
+		"HOME=/tmp",
+		"--env",
+		`GIT_DIR=${WORKSPACE_IN_CONTAINER}/repository.git/worktrees/worktree`,
+		"--env",
+		`GIT_COMMON_DIR=${WORKSPACE_IN_CONTAINER}/repository.git`,
+		"--env",
+		`GIT_WORK_TREE=${WORKSPACE_IN_CONTAINER}/worktree`,
+		PROJECT_IMAGE,
+		"/usr/bin/timeout",
+		`${Math.floor(COMMAND_TIMEOUT_MS / 1e3)}s`,
+		"/bin/bash",
+		"-lc",
+		input.command
+	];
+}
+function assertContainedWorkspace(boundaryRoot, workspacePath) {
+	const within = relative(boundaryRoot, workspacePath);
+	if (!within || within === ".." || within.startsWith(`..${sep}`) || isAbsolute(within)) throw new Error("claude_project.workspace_outside_boundary");
+	return within.split(sep).join("/");
+}
+//#endregion
+//#region src/local-service/state/ledger-io.ts
+function createLedgerIo() {
+	return {
+		appendFile: async (filePath, content, encoding) => {
+			await mkdir(dirnamePath(filePath), { recursive: true });
+			await appendFile(filePath, content, { encoding });
+		},
+		copyFile: async (fromPath, toPath) => {
+			await mkdir(dirnamePath(toPath), { recursive: true });
+			await copyFile(fromPath, toPath);
+		},
+		mkdir: async (dirPath, options) => {
+			await mkdir(dirPath, options);
+		},
+		readFile: async (filePath, encoding) => {
+			return await readFile(filePath, encoding);
+		},
+		rename: async (fromPath, toPath) => {
+			await mkdir(dirnamePath(toPath), { recursive: true });
+			await rename(fromPath, toPath);
+		},
+		syncPath: async (fileOrDirectoryPath) => {
+			const isWindows = process.platform === "win32";
+			if (isWindows && (await stat(fileOrDirectoryPath)).isDirectory()) return;
+			const handle = await open(fileOrDirectoryPath, isWindows ? "r+" : "r");
+			try {
+				await handle.sync();
+			} finally {
+				await handle.close();
+			}
+		},
+		rm: async (filePath, options) => {
+			await rm(filePath, options);
+		},
+		writeFile: async (filePath, content, encoding) => {
+			await mkdir(dirnamePath(filePath), { recursive: true });
+			await writeFile(filePath, content, encoding);
+		}
+	};
+}
+//#endregion
+//#region src/local-service/dispatch/execution-context-workspace.ts
+const execFileAsync$1 = promisify(execFile);
+const syncDirectory = createLedgerIo().syncPath;
+const COMMIT_PATTERN = /^(?:[a-f0-9]{40}|[a-f0-9]{64})$/u;
+const manifestSchema = z.strictObject({
+	version: z.union([z.literal(1), z.literal(2)]),
+	identity: executionContextAssignmentSchema,
+	sourceWorkingDirectory: z.string().nullable(),
+	baseCommit: z.string().regex(COMMIT_PATTERN).nullable(),
+	boundaryRoot: z.string(),
+	workingDirectory: z.string(),
+	status: z.enum([
+		"preparing",
+		"restoring",
+		"completed",
+		"in_use",
+		"retiring",
+		"released"
+	]),
+	pristineFingerprint: z.string().regex(/^[a-f0-9]{64}$/u).optional(),
+	copiedUncommittedFiles: z.literal(false),
+	processSupervisionId: z.uuid().optional(),
+	activeDispatchId: z.string().min(1).optional(),
+	activeAttemptId: z.string().min(1).optional(),
+	containerRuntime: z.strictObject({
+		binary: z.string().min(1),
+		engineIdentity: z.string().min(1),
+		kind: z.enum(["docker", "podman"])
+	}).optional(),
+	retirement: z.strictObject({
+		path: z.string(),
+		pristineFingerprint: z.string().regex(/^[a-f0-9]{64}$/u)
+	}).optional()
+}).refine((manifest) => manifest.version === 2 || (manifest.status === "preparing" || manifest.status === "completed") && !manifest.pristineFingerprint && !manifest.processSupervisionId && !manifest.activeDispatchId && !manifest.activeAttemptId && !manifest.containerRuntime && !manifest.retirement).refine((manifest) => manifest.identity.access === "space_context" ? manifest.sourceWorkingDirectory === null && manifest.baseCommit === null : manifest.sourceWorkingDirectory !== null && isAbsolute(manifest.sourceWorkingDirectory) && manifest.baseCommit !== null && manifest.identity.workspace === "isolated");
+async function prepareExecutionContextWorkspace(input) {
+	const parsed = executionContextTaskSchema.safeParse(input.context);
+	if (!parsed.success) throw failure("invalid_workspace_context");
+	const { nativeConversationId, runtimeWorkspaceFingerprint } = parsed.data;
+	const identity = executionContextAssignmentSchema.strip().parse(parsed.data);
+	const source = identity.access !== "space_context" ? await canonicalDirectory(input.currentWorkingDirectory) : null;
+	if (source) {
+		assertSourceAllowed(source, input.policy);
+		if (identity.workspace === "current") return {
+			workingDirectory: source,
+			boundaryRoot: source
+		};
+	}
+	const ledgerRoot = await ensureDirectory(input.ledgerRootPath, true);
+	const workspaceRoot = await ensureDirectory(join(ledgerRoot, "execution-context-workspaces"));
+	const recordsRoot = await ensureDirectory(join(ledgerRoot, "execution-context-workspace-records"));
+	const boundaryRoot = join(workspaceRoot, identity.id);
+	const workingDirectory = source ? join(boundaryRoot, "worktree") : boundaryRoot;
+	const recordPath = join(recordsRoot, `${identity.id}.json`);
+	return await withWorkspaceLock(ledgerRoot, identity.id, async () => {
+		const stored = await readManifest(recordPath);
+		if (stored) {
+			if (JSON.stringify(stored.identity) !== JSON.stringify(identity) || stored.sourceWorkingDirectory !== source || stored.boundaryRoot !== boundaryRoot || stored.workingDirectory !== workingDirectory) throw failure("workspace_identity_mismatch");
+			await reconcileRetainedWorkspace(stored, recordPath, Boolean(runtimeWorkspaceFingerprint || nativeConversationId), ledgerRoot);
+			return await verifyRetainedWorkspace(stored);
+		}
+		if (runtimeWorkspaceFingerprint || nativeConversationId) throw failure("workspace_record_missing");
+		if (await inspectPath(boundaryRoot)) throw failure("workspace_already_exists");
+		const baseCommit = source ? await resolveSourceCommit(source) : null;
+		const manifest = {
+			version: 2,
+			identity,
+			sourceWorkingDirectory: source,
+			baseCommit,
+			boundaryRoot,
+			workingDirectory,
+			status: "preparing",
+			copiedUncommittedFiles: false,
+			processSupervisionId: randomUUID()
+		};
+		await writeManifest(recordPath, manifest, "wx");
+		await finishWorkspacePreparation(manifest, recordPath, true);
+		return workspaceResult(manifest);
+	});
+}
+async function reconcileRetainedWorkspace(record, path, hasNativeIdentity, ledgerRoot) {
+	if (record.status === "retiring") await runWithHeldLock({
+		lock: await acquireWorkspaceExecutionLock(ledgerRoot, record.identity.id),
+		run: async () => {
+			if (!record.processSupervisionId || (await listAgentControllerSupervisedProcessIds({
+				fresh: true,
+				processId: null,
+				supervisionId: record.processSupervisionId
+			})).length > 0) throw failure("workspace_execution_quiescence_unconfirmed");
+			const reconciled = await finishWorkspaceRetirement(record, path);
+			if (reconciled.status === "released") await restoreReleasedWorkspace(reconciled, path);
+		}
+	});
+	else if (record.status === "released") await restoreReleasedWorkspace(record, path);
+	else if (record.status === "preparing" || record.status === "restoring") {
+		if (record.status === "preparing" && hasNativeIdentity) throw failure("workspace_creation_incomplete");
+		if (!record.processSupervisionId || (await listAgentControllerSupervisedProcessIds({
+			fresh: true,
+			processId: null,
+			supervisionId: record.processSupervisionId
+		})).length > 0) throw failure("workspace_preparation_quiescence_unconfirmed");
+		await finishWorkspacePreparation(record, path);
+	} else if (record.status === "in_use") await runWithHeldLock({
+		lock: await acquireWorkspaceExecutionLock(ledgerRoot, record.identity.id),
+		run: async () => {
+			if (record.containerRuntime) await stopClaudeProjectContainersForContext({
+				contextId: record.identity.id,
+				runtime: record.containerRuntime
+			});
+			if (!record.processSupervisionId || (await listAgentControllerSupervisedProcessIds({
+				fresh: true,
+				processId: null,
+				supervisionId: record.processSupervisionId
+			})).length > 0) throw failure("workspace_execution_quiescence_unconfirmed");
+			await verifyRetainedWorkspace(record);
+			const { activeAttemptId: _activeAttemptId, activeDispatchId: _activeDispatchId, containerRuntime: _containerRuntime, ...reconciled } = record;
+			await writeManifest(path, {
+				...reconciled,
+				status: "completed"
+			}, "r+");
+		}
+	});
+}
+async function finishWorkspacePreparation(manifest, recordPath, pristineCreation = false) {
+	const { boundaryRoot, workingDirectory, sourceWorkingDirectory: source, baseCommit } = manifest;
+	await ensureDirectory(boundaryRoot);
+	const repository = join(boundaryRoot, "repository.git");
+	if (source && baseCommit) {
+		if (!await inspectPath(repository)) {
+			if ((await readdir(boundaryRoot)).length > 0) throw failure("workspace_creation_incomplete");
+			await git(boundaryRoot, [
+				"init",
+				"--bare",
+				"--template=",
+				`--object-format=${baseCommit.length === 64 ? "sha256" : "sha1"}`,
+				repository
+			], manifest.processSupervisionId);
+		}
+		await canonicalDirectory(repository);
+		await assertPrivateMetadata(repository);
+		if ((await readdir(boundaryRoot)).some((name) => name !== "repository.git" && name !== "worktree")) throw failure("workspace_creation_incomplete");
+		if (await inspectPath(join(repository, "objects", "info", "alternates"))) throw failure("workspace_git_metadata_changed");
+		if (!await inspectPath(workingDirectory)) {
+			await git(boundaryRoot, [
+				`--git-dir=${repository}`,
+				"fetch",
+				"--no-tags",
+				"--no-recurse-submodules",
+				"--depth=1",
+				"--no-write-fetch-head",
+				source,
+				`${baseCommit}:refs/openmeld/base`
+			], manifest.processSupervisionId);
+			await git(boundaryRoot, [
+				`--git-dir=${repository}`,
+				"worktree",
+				"add",
+				"--detach",
+				workingDirectory,
+				baseCommit
+			], manifest.processSupervisionId);
+		}
+		await verifyOwnedRepository(manifest);
+		await finishMissingCheckoutFiles(manifest);
+		if (!await isUnchangedCheckout(manifest)) throw failure("workspace_creation_incomplete");
+	} else if ((await readdir(boundaryRoot)).length > 0) throw failure("workspace_creation_incomplete");
+	await writeManifest(recordPath, {
+		...manifest,
+		status: "completed",
+		pristineFingerprint: pristineCreation ? await fingerprintDirectory(boundaryRoot) : void 0
+	}, "r+");
+}
+async function readExecutionContextWorkspace(input) {
+	if (!executionContextAssignmentSchema.shape.id.safeParse(input.contextId).success) throw failure("invalid_workspace_context");
+	if (!await inspectPath(input.ledgerRootPath)) return null;
+	const ledgerRoot = await canonicalDirectory(input.ledgerRootPath);
+	const recordsRoot = join(ledgerRoot, "execution-context-workspace-records");
+	if (!await inspectPath(recordsRoot)) return null;
+	await canonicalDirectory(recordsRoot);
+	const manifest = await readManifest(join(recordsRoot, `${input.contextId}.json`));
+	if (!manifest) return null;
+	const boundaryRoot = join(await canonicalDirectory(join(ledgerRoot, "execution-context-workspaces")), input.contextId);
+	const workingDirectory = manifest.identity.access !== "space_context" ? join(boundaryRoot, "worktree") : boundaryRoot;
+	if (manifest.identity.id !== input.contextId || manifest.boundaryRoot !== boundaryRoot || manifest.workingDirectory !== workingDirectory) throw failure("workspace_identity_mismatch");
+	if (manifest.status === "released" || manifest.status === "retiring") return workspaceResult(manifest);
+	if (manifest.status === "preparing" || manifest.status === "restoring") throw failure("workspace_creation_incomplete");
+	return await verifyRetainedWorkspace(manifest);
+}
+async function markExecutionContextWorkspaceInUse(input) {
+	const context = input.context;
+	if (!context || context.workspace !== "isolated" || context.access === "space_context") return null;
+	const root = await canonicalDirectory(input.ledgerRootPath);
+	const lock = await acquireWorkspaceExecutionLock(root, context.id);
+	const processSupervisionId = randomUUID();
+	try {
+		await withWorkspaceLock(root, context.id, async () => {
+			await readExecutionContextWorkspace({
+				ledgerRootPath: root,
+				contextId: context.id
+			});
+			const path = join(root, "execution-context-workspace-records", `${context.id}.json`);
+			const record = await readManifest(path);
+			if (record?.status !== "completed") throw failure("workspace_execution_quiescence_unconfirmed");
+			await writeManifest(path, {
+				...record,
+				status: "in_use",
+				processSupervisionId,
+				...input.containerRuntime && input.dispatchId && input.attemptId ? {
+					activeDispatchId: input.dispatchId,
+					activeAttemptId: input.attemptId
+				} : {},
+				...input.containerRuntime ? { containerRuntime: input.containerRuntime } : {}
+			}, "r+");
+		});
+		return {
+			lock,
+			processSupervisionId
+		};
+	} catch (error) {
+		await releaseLock(lock);
+		throw error;
+	}
+}
+async function releaseExecutionContextWorkspace(input) {
+	const root = await canonicalDirectory(input.ledgerRootPath);
+	try {
+		return await withWorkspaceLock(root, input.context.id, async () => {
+			await readExecutionContextWorkspace({
+				ledgerRootPath: root,
+				contextId: input.context.id
+			});
+			const path = join(root, "execution-context-workspace-records", `${input.context.id}.json`);
+			let record = await readManifest(path);
+			if (!(record && ["completed", "in_use"].includes(record.status))) throw failure("workspace_creation_incomplete");
+			if (record.containerRuntime) await stopClaudeProjectContainersForContext({
+				contextId: record.identity.id,
+				runtime: record.containerRuntime
+			});
+			if (!input.ownedProcessesQuiescent) return {
+				status: "retained",
+				reason: "execution_quiescence_unconfirmed"
+			};
+			const { activeAttemptId: _activeAttemptId, activeDispatchId: _activeDispatchId, containerRuntime: _containerRuntime, ...quiescentRecord } = record;
+			const completed = {
+				...quiescentRecord,
+				status: "completed"
+			};
+			await writeManifest(path, completed, "r+");
+			record = await removePristineRetirement(completed, path);
+			if (record.retirement) return {
+				status: "retained",
+				reason: "cleanup_incomplete"
+			};
+			if (!record.pristineFingerprint) return {
+				status: "retained",
+				reason: "baseline_unverified"
+			};
+			await verifyRetainedWorkspace(record);
+			if (await fingerprintDirectory(record.boundaryRoot) !== record.pristineFingerprint) return {
+				status: "retained",
+				reason: "workspace_changed"
+			};
+			if (record.sourceWorkingDirectory && !await sourceHasCommit(record)) return {
+				status: "retained",
+				reason: "source_commit_unavailable"
+			};
+			return (await retirePristineWorkspace(record, path)).status === "released" ? { status: "released" } : {
+				status: "retained",
+				reason: "workspace_changed"
+			};
+		});
+	} finally {
+		if (input.use) await releaseLock(input.use.lock);
+	}
+}
+async function assertExecutionContextWorkspaceUse(input) {
+	if (!executionContextAssignmentSchema.shape.id.safeParse(input.contextId).success) throw failure("workspace_identity_mismatch");
+	const record = await readManifest(join(await canonicalDirectory(input.ledgerRootPath), "execution-context-workspace-records", `${input.contextId}.json`));
+	if (record?.status !== "in_use" || record.identity.id !== input.contextId || record.activeDispatchId !== input.dispatchId || record.activeAttemptId !== input.attemptId || !record.containerRuntime) throw failure("workspace_execution_authority_mismatch");
+}
+async function runExecutionContextWorkspaceProjectShell(input) {
+	const root = await canonicalDirectory(input.ledgerRootPath);
+	return await withWorkspaceLock(root, input.contextId, async () => {
+		await assertExecutionContextWorkspaceUse({
+			ledgerRootPath: root,
+			contextId: input.contextId,
+			dispatchId: input.dispatchId,
+			attemptId: input.attemptId
+		});
+		const record = await readManifest(join(root, "execution-context-workspace-records", `${input.contextId}.json`));
+		if (record?.boundaryRoot !== input.boundaryRoot || record.workingDirectory !== input.workspacePath || record.containerRuntime?.binary !== input.runtime.binary || record.containerRuntime.engineIdentity !== input.runtime.engineIdentity || record.containerRuntime.kind !== input.runtime.kind) throw failure("workspace_execution_authority_mismatch");
+		return await runClaudeProjectContainerCommand({
+			command: input.command,
+			contextId: input.contextId,
+			runtime: input.runtime,
+			boundaryRoot: input.boundaryRoot,
+			workspacePath: input.workspacePath
+		});
+	});
+}
+async function retirePristineWorkspace(record, recordPath) {
+	if (!record.pristineFingerprint || await fingerprintDirectory(record.boundaryRoot) !== record.pristineFingerprint) throw failure("workspace_release_incomplete");
+	const retiring = {
+		...record,
+		status: "retiring",
+		retirement: {
+			path: `${recordPath}.retired-${randomUUID()}`,
+			pristineFingerprint: record.pristineFingerprint
+		}
+	};
+	await writeManifest(recordPath, retiring, "r+");
+	return await finishWorkspaceRetirement(retiring, recordPath);
+}
+async function finishWorkspaceRetirement(record, recordPath) {
+	const retirement = record.retirement;
+	if (!retirement) throw failure("workspace_release_incomplete");
+	const live = await inspectPath(record.boundaryRoot);
+	const retired = await inspectPath(retirement.path);
+	if (live && retired || !(live || retired)) throw failure("workspace_release_incomplete");
+	if (live) await moveWorkspace(record.boundaryRoot, retirement.path);
+	if (await fingerprintDirectory(retirement.path) !== retirement.pristineFingerprint) {
+		if (await inspectPath(record.boundaryRoot)) throw failure("workspace_release_incomplete");
+		await moveWorkspace(retirement.path, record.boundaryRoot);
+		const retained = {
+			...record,
+			retirement: void 0,
+			status: "completed"
+		};
+		await writeManifest(recordPath, retained, "r+");
+		return retained;
+	}
+	const released = {
+		...record,
+		status: "released"
+	};
+	await writeManifest(recordPath, released, "r+");
+	return await removePristineRetirement(released, recordPath);
+}
+async function removePristineRetirement(record, recordPath) {
+	const retirement = record.retirement;
+	if (!retirement) return record;
+	if (await inspectPath(retirement.path)) {
+		if (await fingerprintDirectory(retirement.path) !== retirement.pristineFingerprint) return record;
+		await rm(retirement.path, { recursive: true });
+	}
+	const removed = {
+		...record,
+		retirement: void 0
+	};
+	await writeManifest(recordPath, removed, "r+");
+	return removed;
+}
+async function restoreReleasedWorkspace(record, recordPath) {
+	if (record.sourceWorkingDirectory && !await sourceHasCommit(record)) throw failure("workspace_base_commit_unavailable");
+	if (await inspectPath(record.boundaryRoot)) throw failure("workspace_already_exists");
+	const restoring = {
+		...record,
+		status: "restoring",
+		processSupervisionId: randomUUID()
+	};
+	await writeManifest(recordPath, restoring, "r+");
+	await finishWorkspacePreparation(restoring, recordPath, true);
+}
+async function sourceHasCommit(record) {
+	if (!(record.sourceWorkingDirectory && record.baseCommit)) return false;
+	try {
+		await git(record.sourceWorkingDirectory, [
+			"cat-file",
+			"-e",
+			`${record.baseCommit}^{commit}`
+		]);
+		return true;
+	} catch {
+		return false;
+	}
+}
+async function isUnchangedCheckout(record) {
+	return await git(record.workingDirectory, ["rev-parse", "HEAD"]) === record.baseCommit && await git(record.workingDirectory, [
+		"status",
+		"--porcelain",
+		"--untracked-files=all",
+		"--ignored"
+	]) === "";
+}
+async function finishMissingCheckoutFiles(record) {
+	if (await git(record.workingDirectory, ["rev-parse", "HEAD"]) !== record.baseCommit) throw failure("workspace_creation_incomplete");
+	if ((await git(record.workingDirectory, [
+		"ls-files",
+		"-v",
+		"-z"
+	])).split("\0").some((entry) => entry && !entry.startsWith("H "))) throw failure("workspace_creation_incomplete");
+	const status = await git(record.workingDirectory, [
+		"status",
+		"--porcelain",
+		"-z",
+		"--untracked-files=all",
+		"--ignored"
+	]);
+	if (!status) return;
+	const changes = status.split("\0").filter(Boolean);
+	if (changes.some((entry) => !entry.startsWith(" D "))) throw failure("workspace_creation_incomplete");
+	const paths = changes.map((entry) => entry.slice(3));
+	for (let offset = 0; offset < paths.length; offset += 100) await git(record.workingDirectory, [
+		"checkout-index",
+		"--",
+		...paths.slice(offset, offset + 100)
+	], record.processSupervisionId);
+}
+async function fingerprintDirectory(root) {
+	const hash = createHash("sha256");
+	const visit = async (directory) => {
+		for (const name of (await readdir(directory)).sort()) {
+			const path = join(directory, name);
+			const info = await lstat(path);
+			hash.update(JSON.stringify([
+				relative(root, path),
+				info.mode,
+				info.nlink
+			]));
+			if (info.isSymbolicLink()) hash.update(JSON.stringify(await readlink(path)));
+			else if (info.isDirectory()) await visit(path);
+			else if (info.isFile() && info.nlink === 1) {
+				hash.update(String(info.size));
+				hash.update(await fingerprintFile(path));
+			} else throw failure("workspace_git_metadata_changed");
+		}
+	};
+	await visit(root);
+	return hash.digest("hex");
+}
+async function fingerprintFile(path) {
+	const hash = createHash("sha256");
+	const file = await open(path, "r");
+	try {
+		const buffer = Buffer.alloc(64 * 1024);
+		for (;;) {
+			const { bytesRead } = await file.read(buffer);
+			if (!bytesRead) break;
+			hash.update(buffer.subarray(0, bytesRead));
+		}
+	} finally {
+		await file.close();
+	}
+	return hash.digest("hex");
+}
+async function withWorkspaceLock(root, contextId, run) {
+	if (!executionContextAssignmentSchema.shape.id.safeParse(contextId).success) throw failure("invalid_workspace_context");
+	return await runWithHeldLock({
+		lock: await acquireLock({
+			openMeldProfileId: "execution-context-workspaces",
+			key: contextId,
+			pathResolution: { env: { OPENMELD_HOME: root } }
+		}),
+		run
+	});
+}
+async function verifyRetainedWorkspace(manifest) {
+	await canonicalDirectory(manifest.boundaryRoot);
+	await canonicalDirectory(manifest.workingDirectory);
+	if (manifest.sourceWorkingDirectory) await verifyOwnedRepository(manifest);
+	return workspaceResult(manifest);
+}
+async function acquireWorkspaceExecutionLock(root, contextId) {
+	return await acquireLock({
+		openMeldProfileId: "execution-context-workspaces",
+		key: `${contextId}-execution`,
+		pathResolution: { env: { OPENMELD_HOME: root } }
+	});
+}
+function workspaceResult(manifest) {
+	return {
+		workingDirectory: manifest.workingDirectory,
+		boundaryRoot: manifest.boundaryRoot,
+		...manifest.sourceWorkingDirectory ? { sourceWorkingDirectory: manifest.sourceWorkingDirectory } : {},
+		...manifest.baseCommit ? { baseCommit: manifest.baseCommit } : {}
+	};
+}
+function assertSourceAllowed(source, policy) {
+	if (policy.mode === "only_selected_folders" && !policy.folders.some((folder) => within(source, folder))) throw failure("workspace_outside_computer_policy");
+	if (policy.mode === "block_selected_folders" && policy.folders.some((folder) => within(source, folder) || within(folder, source))) throw failure("workspace_overlaps_blocked_folder");
+}
+async function resolveSourceCommit(source) {
+	if (!await inspectPath(join(source, ".git"))) throw failure("project_repository_required");
+	if (await realpath(await git(source, ["rev-parse", "--show-toplevel"])) !== source) throw failure("project_repository_root_required");
+	const commit = await git(source, [
+		"rev-parse",
+		"--verify",
+		"HEAD^{commit}"
+	]).catch((cause) => {
+		throw new Error("execution_context.project_commit_required", { cause });
+	});
+	if (!COMMIT_PATTERN.test(commit)) throw failure("project_commit_required");
+	return commit;
+}
+async function verifyOwnedRepository(manifest) {
+	const repository = join(manifest.boundaryRoot, "repository.git");
+	await canonicalDirectory(repository);
+	await assertPrivateMetadata(repository);
+	if (await inspectPath(join(repository, "objects", "info", "alternates"))) throw failure("workspace_git_metadata_changed");
+	const gitFile = join(manifest.workingDirectory, ".git");
+	const gitFileInfo = await inspectPath(gitFile);
+	if (!gitFileInfo?.isFile() || gitFileInfo.size > 4096) throw failure("workspace_git_metadata_changed");
+	const expectedGitDir = join(repository, "worktrees", "worktree");
+	const gitDirLine = (await readFile(gitFile, "utf8")).trim();
+	const gitDir = gitDirLine.startsWith("gitdir: ") ? gitDirLine.slice(8) : null;
+	if (!(gitDir && isAbsolute(gitDir)) || relative(expectedGitDir, gitDir)) throw failure("workspace_git_metadata_changed");
+	if (await realpath(join(expectedGitDir, (await readFile(join(expectedGitDir, "commondir"), "utf8")).trim())) !== repository) throw failure("workspace_git_metadata_changed");
+	if (await git(manifest.boundaryRoot, [
+		`--git-dir=${repository}`,
+		"rev-parse",
+		"--verify",
+		"refs/openmeld/base^{commit}"
+	]) !== manifest.baseCommit) throw failure("workspace_base_commit_changed");
+}
+async function assertPrivateMetadata(path) {
+	for (const entry of await readdir(path, { withFileTypes: true })) {
+		if (entry.isSymbolicLink()) throw failure("workspace_is_symlink");
+		if (entry.isDirectory()) await assertPrivateMetadata(join(path, entry.name));
+		else if ((await lstat(join(path, entry.name))).nlink !== 1) throw failure("workspace_git_metadata_changed");
+	}
+}
+async function readManifest(path) {
+	const info = await inspectPath(path);
+	if (!info) return null;
+	if (!info.isFile() || info.size > 32768) throw failure("workspace_record_invalid");
+	let content;
+	try {
+		content = JSON.parse(await readFile(path, "utf8"));
+	} catch {
+		throw failure("workspace_record_invalid");
+	}
+	const parsed = manifestSchema.safeParse(content);
+	if (!parsed.success) throw failure("workspace_record_invalid");
+	const retirement = parsed.data.retirement;
+	const prefix = `${path}.retired-`;
+	if (parsed.data.status === "retiring" && !retirement || retirement && !(retirement.path.startsWith(prefix) && z.uuid().safeParse(retirement.path.slice(prefix.length)).success)) throw failure("workspace_record_invalid");
+	return parsed.data;
+}
+async function writeManifest(path, manifest, flags) {
+	const temporaryPath = flags === "wx" ? path : `${path}.${randomUUID()}.tmp`;
+	const file = await open(temporaryPath, "wx", 384);
+	try {
+		await file.writeFile(`${JSON.stringify({
+			...manifest,
+			version: 2
+		})}\n`, "utf8");
+		await file.sync();
+	} finally {
+		await file.close();
+	}
+	if (flags !== "wx") await rename(temporaryPath, path);
+	await syncDirectory(dirname(path));
+}
+async function moveWorkspace(from, to) {
+	await rename(from, to);
+	await syncDirectory(dirname(from));
+	await syncDirectory(dirname(to));
+}
+async function inspectPath(path) {
+	const info = await lstat(path).catch((error) => {
+		if (error.code === "ENOENT") return null;
+		throw error;
+	});
+	if (info?.isSymbolicLink()) throw failure("workspace_is_symlink");
+	return info;
+}
+async function canonicalDirectory(path) {
+	if (!(await inspectPath(path))?.isDirectory()) throw failure("workspace_directory_unavailable");
+	return await realpath(path);
+}
+async function ensureDirectory(path, recursive = false) {
+	await inspectPath(path);
+	await mkdir(path, {
+		recursive,
+		mode: 448
+	}).catch((error) => {
+		if (error.code !== "EEXIST") throw error;
+	});
+	return await canonicalDirectory(path);
+}
+function within(child, parent) {
+	const path = relative(resolve(parent), child);
+	return path === "" || path !== ".." && !path.startsWith(`..${sep}`) && !isAbsolute(path);
+}
+const GIT_SETTINGS = {
+	"core.hooksPath": "/dev/null",
+	"core.attributesFile": "/dev/null",
+	"core.fsmonitor": "false",
+	"credential.helper": "",
+	"protocol.allow": "never",
+	"protocol.file.allow": "always",
+	"fetch.recurseSubmodules": "false",
+	"submodule.recurse": "false",
+	"uploadpack.packObjectsHook": "",
+	"gc.auto": "0",
+	"maintenance.auto": "false"
+};
+async function git(cwd, args, processSupervisionId) {
+	const env = Object.fromEntries(Object.entries(process.env).filter(([key]) => !key.startsWith("GIT_")));
+	Object.assign(env, {
+		...processSupervisionId ? { OPENMELD_PROCESS_SUPERVISION_ID: processSupervisionId } : {},
+		GIT_CONFIG_NOSYSTEM: "1",
+		GIT_CONFIG_SYSTEM: "/dev/null",
+		GIT_CONFIG_GLOBAL: "/dev/null",
+		GIT_ATTR_NOSYSTEM: "1",
+		GIT_NO_REPLACE_OBJECTS: "1",
+		GIT_NO_LAZY_FETCH: "1",
+		GIT_ALLOW_PROTOCOL: "file",
+		GIT_TERMINAL_PROMPT: "0",
+		GIT_CONFIG_COUNT: String(Object.keys(GIT_SETTINGS).length)
+	});
+	for (const [index, [key, value]] of Object.entries(GIT_SETTINGS).entries()) {
+		env[`GIT_CONFIG_KEY_${index}`] = key;
+		env[`GIT_CONFIG_VALUE_${index}`] = value;
+	}
+	return (await execFileAsync$1("git", args, {
+		cwd,
+		env,
+		encoding: "utf8",
+		timeout: 3e4,
+		maxBuffer: 1024 * 1024
+	})).stdout.trimEnd();
+}
+function failure(code) {
+	return /* @__PURE__ */ new Error(`execution_context.${code}`);
+}
+//#endregion
+//#region src/space/action-command.ts
+const FINAL_SAFE_STATUSES = /* @__PURE__ */ new Set([
+	"blocked",
+	"done",
+	"handoff",
+	"needs_input"
+]);
+const DISPATCH_ACTION_CLI_PLACEHOLDER = "<DISPATCH_ACTION_CLI>";
+const SPACE_ACTION_REPLY_TIMING_EVENT = "openmeld.space_action.reply_timing";
+function runSpaceActionReply(input) {
+	const text = resolveReplyMessageText(input);
+	const result = recordDispatchSpaceReply({
+		filePaths: input.filePaths,
+		messagePartCount: input.messageParts.length,
+		mentionTargets: input.mentionTargets,
+		referenceTargets: input.referenceTargets,
+		text,
+		wakeTargets: input.wakeTargets
+	});
+	if (result instanceof Promise) return result.then((record) => {
+		emitActionRecorded(record);
+	});
+	emitActionRecorded(result);
+}
+function recordDispatchSpaceReply(input) {
+	const timing = createSpaceActionReplyTiming();
+	timing.emit("command_start", void 0, {
+		messagePartCount: input.messagePartCount ?? 0,
+		mentionTargetCount: input.mentionTargets?.length ?? 0,
+		referenceTargetCount: input.referenceTargets?.length ?? 0,
+		wakeTargetCount: input.wakeTargets?.length ?? 0
+	});
+	const filePaths = input.filePaths ?? [];
+	if (filePaths.length && input.files?.length) throw new DispatchSpaceActionRejectedError("space_action.invalid_input", "Choose uploaded paths or saved file revisions for this reply.");
+	const context = filePaths.length > 0 ? readDispatchSpaceActionContextFromEnv(input.env) : readDispatchSpaceActionContextForReceiptFromEnv(input.env);
+	timing.emit("context_ready", context);
+	assertAllowedAction(context, "post_message");
+	const text = normalizeRequiredText(input.text, "Reply message is required.");
+	const targetIds = resolveMessageEnvelopeTargetIds({
+		context,
+		mentionTargets: input.mentionTargets ?? [],
+		wakeTargets: input.wakeTargets ?? [],
+		referenceTargets: input.referenceTargets ?? []
+	});
+	timing.emit("targets_resolved", context, {
+		activationTargetCount: targetIds.activationTargets.length,
+		messageLength: text.length,
+		mentionTargetCount: targetIds.mentionTargets.length,
+		referenceTargetCount: targetIds.referenceTargets.length
+	});
+	if (filePaths.length === 0) return writeSpaceActionReplyRecord({
+		context,
+		files: input.files ? [...input.files] : [],
+		targetIds,
+		text,
+		timing
+	});
+	return uploadAndRecordSpaceActionReply({
+		context,
+		filePaths,
+		targetIds,
+		text,
+		timing
+	});
+}
+function resolveReplyMessageText(input) {
+	const hasInlineMessage = input.messageParts.length > 0;
+	const messageFilePath = input.messageFilePath?.trim();
+	if (hasInlineMessage && messageFilePath) throw new Error("Choose either a reply message or --message-file, not both.");
+	if (!messageFilePath) return normalizeRequiredJoinedText(input.messageParts, "Reply message is required.");
+	return normalizeRequiredText(readFileSync(messageFilePath === "-" ? 0 : messageFilePath, { encoding: "utf8" }), "Reply message is required.");
+}
+async function uploadAndRecordSpaceActionReply(input) {
+	const files = await uploadSpaceActionReplyFiles({
+		context: input.context,
+		filePaths: input.filePaths
+	});
+	return writeSpaceActionReplyRecord({
+		...input,
+		files
+	});
+}
+function writeSpaceActionReplyRecord(input) {
+	const record = recordAction({
+		action: {
+			type: "post_message",
+			...input.files.length > 0 ? { files: [...input.files] } : {},
+			messageEnvelope: {
+				activationTargets: input.targetIds.activationTargets,
+				mentionTargets: input.targetIds.mentionTargets,
+				referenceTargets: input.targetIds.referenceTargets,
+				...input.context.replyToSignalId ? { replyToSignalId: input.context.replyToSignalId } : {},
+				text: input.text
+			}
+		},
+		command: "reply",
+		context: input.context
+	});
+	input.timing.emit("record_written", input.context, { actionType: record.action.type });
+	input.timing.emit("done", input.context, { actionType: record.action.type });
+	return record;
+}
+async function uploadSpaceActionReplyFiles(input) {
+	const prepared = await prepareRequestedSpaceSendFiles({ filePaths: input.filePaths });
+	if (prepared.length === 0) return [];
+	return await uploadPreparedSpaceFiles({
+		files: prepared,
+		requestContext: buildOpenMeldRequestContextFromProfile({ openMeldProfile: await requireOpenMeldProfile({
+			openMeldProfileId: input.context.targetProfileId,
+			persistSelection: false,
+			authAction: "sharing files in a Space reply"
+		}) }),
+		spaceApi: createCliSpaceApi(await resolveBaseUrl()),
+		spaceId: input.context.spaceId
+	});
+}
+function runSpaceActionWake(input) {
+	const context = readDispatchSpaceActionContextForReceiptFromEnv();
+	assertAllowedAction(context, "post_message");
+	const text = normalizeRequiredJoinedText(input.messageParts, "Wake handoff message is required.");
+	recordAction({
+		action: {
+			type: "post_message",
+			messageEnvelope: {
+				activationTargets: resolveTargetProfileIds({
+					context,
+					relation: "wake",
+					targets: [input.target]
+				}),
+				mentionTargets: [],
+				referenceTargets: [],
+				...context.replyToSignalId ? { replyToSignalId: context.replyToSignalId } : {},
+				text
+			}
+		},
+		command: "wake",
+		context
+	});
+}
+function runSpaceActionStatus(input) {
+	emitActionRecorded(recordDispatchSpaceStatus({
+		status: input.status,
+		text: normalizeRequiredJoinedText(input.textParts, "Status text is required.")
+	}));
+}
+/** Legacy CLI/in-flight compatibility only; not offered to current Agent tool catalogs. */
+function recordDispatchSpaceStatus(input) {
+	const context = readDispatchSpaceActionContextForReceiptFromEnv();
+	assertAllowedAction(context, "post_status");
+	return recordAction({
+		action: {
+			type: "post_status",
+			status: normalizeStatus(input.status),
+			text: normalizeRequiredText(input.text, "Status text is required.")
+		},
+		command: "status",
+		context
+	});
+}
+function runSpaceActionSilent(input) {
+	emitActionRecorded(recordDispatchSpaceSilent(input));
+}
+function recordDispatchSpaceSilent(input) {
+	const context = readDispatchSpaceActionContextForReceiptFromEnv(input.env);
+	assertAllowedAction(context, "stay_silent");
+	return recordAction({
+		action: {
+			type: "stay_silent",
+			reason: normalizeRequiredText(input.reason, "A silent action requires --reason.")
+		},
+		command: "silent",
+		context
+	});
+}
+function runSpaceActionTargets() {
+	const targetReference = requireLoadedTargets(readDispatchSpaceActionContextFromEnv().sendTargetReference);
+	const wakeTargets = targetReference.projection.filter((target) => target.allowedRelations.wake);
+	const referenceTargets = targetReference.projection.filter((target) => target.allowedRelations.reference);
+	const mentionTargets = targetReference.projection.filter((target) => target.allowedRelations.mention);
+	outLine("Wake targets:");
+	if (wakeTargets.length === 0) outLine("- none");
+	else for (const target of wakeTargets) outLine(`- ${formatTargetLine(target, "wake")}`);
+	outLine("");
+	outLine("Mention targets:");
+	if (mentionTargets.length === 0) outLine("- none");
+	else for (const target of mentionTargets) outLine(`- ${formatTargetLine(target, "mention")}`);
+	outLine("");
+	outLine("Reference targets:");
+	if (referenceTargets.length === 0) outLine("- none");
+	else for (const target of referenceTargets) outLine(`- ${formatTargetLine(target, "reference")}`);
+}
+function runSpaceActionHelp() {
+	let context = null;
+	try {
+		context = readDispatchSpaceActionContextFromEnv();
+	} catch {
+		context = null;
+	}
+	outLine("OpenMeld Space Action commands:");
+	outLine(formatSpaceActionHelpExample("Reply", "reply \"message\"", context));
+	outLine(formatSpaceActionHelpExample("Handoff and wake another agent", "wake <agent-profile-id> \"summary and request\"", context));
+	outLine(formatSpaceActionHelpExample("Reply and also wake another agent", "reply --wake <agent-profile-id> \"message\"", context));
+	outLine(formatSpaceActionHelpExample("Reply and reference another agent", "reply --reference <agent-profile-id> \"message\"", context));
+	outLine(formatSpaceActionHelpExample("Reply and mention a person", "reply --mention <human-profile-id> \"message\"", context));
+	outLine(formatSpaceActionHelpExample("Stay silent", "silent --reason \"No public reply is needed.\"", context));
+	outLine(formatSpaceActionHelpExample("Current targets", "targets", context));
+	outLine(formatSpaceActionHelpExample("Help", "help", context));
+	outLine("");
+	outLine("Run exactly one final action for the current Wake. OpenMeld posts the accepted action to the Space.");
+	if (!context) {
+		outLine("");
+		outLine(`No active dispatch context was found. ${DISPATCH_ACTION_CLI_PLACEHOLDER} is a placeholder for the exact Space Action command prefix printed in an OpenMeld Space Wake dispatch prompt.`);
+		outLine("Write actions and targets require an active OpenMeld Space Wake dispatch. Do not guess the command prefix or rewrite it to npx.");
+		return;
+	}
+	outLine("");
+	outLine(`Active dispatch: ${context.dispatchId}`);
+	outLine(`Current target profile: ${context.targetProfileId}`);
+}
+function formatSpaceActionHelpExample(label, action, context) {
+	return `- ${label}: ${formatSpaceActionHelpCommand(action, context)}`;
+}
+function formatSpaceActionHelpCommand(action, context) {
+	if (!context) return `${DISPATCH_ACTION_CLI_PLACEHOLDER} space action ${action}`;
+	return formatOpenMeldCliCommand(`openmeld space action ${action}`);
+}
+function recordAction(input) {
+	return writeDispatchSpaceActionRecord(input);
+}
+function emitActionRecorded(record) {
+	outLine(`Action recorded: OpenMeld saved this unpublished Space action proposal (${record.action.type}) for the current Wake.`);
+}
+function createSpaceActionReplyTiming() {
+	const startedAt = performance.now();
+	let previousAt = startedAt;
+	const commandStartProcessUptimeMs = Math.round(startedAt);
+	return { emit: (phase, context, fields = {}) => {
+		const now = performance.now();
+		const elapsedMs = Math.max(0, Math.round(now - startedAt));
+		const durationMs = Math.max(0, Math.round(now - previousAt));
+		previousAt = now;
+		process.stderr.write(`[${SPACE_ACTION_REPLY_TIMING_EVENT}] ${JSON.stringify({
+			event: SPACE_ACTION_REPLY_TIMING_EVENT,
+			phase,
+			elapsedMs,
+			durationMs,
+			commandStartProcessUptimeMs,
+			attemptId: context?.attemptId ?? null,
+			dispatchId: context?.dispatchId ?? null,
+			spaceId: context?.spaceId ?? null,
+			targetProfileId: context?.targetProfileId ?? null,
+			taskId: context?.taskId ?? null,
+			...fields
+		})}\n`);
+	} };
+}
+function resolveMessageEnvelopeTargetIds(input) {
+	const targets = {
+		activationTargets: resolveTargetProfileIds({
+			context: input.context,
+			relation: "wake",
+			targets: input.wakeTargets
+		}),
+		mentionTargets: resolveTargetProfileIds({
+			context: input.context,
+			relation: "mention",
+			targets: input.mentionTargets
+		}),
+		referenceTargets: resolveTargetProfileIds({
+			context: input.context,
+			relation: "reference",
+			targets: input.referenceTargets
+		})
+	};
+	assertDistinctMessageEnvelopeTargets(targets);
+	return targets;
+}
+function assertDistinctMessageEnvelopeTargets(input) {
+	const seen = /* @__PURE__ */ new Map();
+	const relationTargets = [
+		["wake", input.activationTargets],
+		["reference", input.referenceTargets],
+		["mention", input.mentionTargets]
+	];
+	for (const [relation, profileIds] of relationTargets) for (const profileId of profileIds) {
+		const existingRelation = seen.get(profileId);
+		if (!existingRelation) {
+			seen.set(profileId, relation);
+			continue;
+		}
+		if (existingRelation === relation) throw new DispatchSpaceActionRejectedError("space_action.invalid_input", `The same target (${profileId}) was listed more than once as ${formatRelation(relation)}. Choose it once, or send separate messages.`);
+		throw new DispatchSpaceActionRejectedError("space_action.invalid_input", `The same target (${profileId}) cannot be both ${formatRelation(existingRelation)} and ${formatRelation(relation)} in one Space Action. Choose one relationship, or send separate messages.`);
+	}
+}
+function assertAllowedAction(context, actionType) {
+	const allowedActions = context.spaceContractSnapshot?.allowedActions ?? null;
+	if (allowedActions && !allowedActions.includes(actionType)) throw new DispatchSpaceActionRejectedError("space_action.not_allowed", `This Space does not allow ${actionType}. Do not retry it through another tool or transport.`);
+}
+function normalizeStatus(value) {
+	const normalized = value.trim().toLowerCase();
+	if (normalized === "working") throw new Error("`working` would close the current Wake. Non-final progress updates are not supported by OpenMeld Space Action yet.");
+	if (normalized === "blocked" || normalized === "done" || normalized === "handoff" || normalized === "needs_input") return normalized;
+	if (!FINAL_SAFE_STATUSES.has(normalized)) throw new Error("Status must be one of: done, blocked, needs_input, handoff.");
+	return normalized;
+}
+function resolveTargetProfileIds(input) {
+	return [...new Set(input.targets)].map((target) => resolveTargetProfileId({
+		context: input.context,
+		relation: input.relation,
+		target
+	}));
+}
+function resolveTargetProfileId(input) {
+	const targetReference = requireLoadedTargets(input.context.sendTargetReference);
+	const query = normalizeRequiredText(input.target, "Target is required.");
+	const selected = targetReference.projection.find((target) => target.profileId === query);
+	if (!selected) throw new DispatchSpaceActionRejectedError("space_action.invalid_input", `No current Space target has Profile ID "${query}". Use a full Profile ID from this Wake's current send target reference, or omit the target for a plain reply.`);
+	if (!selected.allowedRelations[input.relation]) throw new DispatchSpaceActionRejectedError("space_action.not_allowed", `${formatRelation(input.relation)} is not allowed for ${selected.primaryMentionLabel}. Do not bypass this restriction through another transport.`);
+	return selected.profileId;
+}
+function requireLoadedTargets(targetReference) {
+	if (targetReference.status === "loaded") return targetReference;
+	throw new DispatchSpaceActionRejectedError("space_action.targets_unavailable", `Current Space targets are not available for this dispatch: ${targetReference.errorMessage}. Do not guess recipients. A plain reply needs no recipients.`);
+}
+function formatTargetLine(target, relation) {
+	const relationLabel = formatRelation(relation);
+	return `${target.primaryMentionLabel} · ${target.profileKind} · ${relationLabel} · ${target.profileId}`;
+}
+function formatRelation(relation) {
+	switch (relation) {
+		case "wake": return "Wake";
+		case "reference": return "Reference";
+		default: return relation;
+	}
+}
+function normalizeRequiredJoinedText(parts, errorMessage) {
+	return normalizeRequiredText(parts.join(" "), errorMessage);
+}
+function normalizeRequiredText(value, errorMessage) {
+	const normalized = String(value ?? "").trim();
+	if (normalized.length === 0) throw new DispatchSpaceActionRejectedError("space_action.invalid_input", errorMessage);
+	return normalized;
+}
+//#endregion
+//#region src/space/dispatch-file-read.ts
+const execFileAsync = promisify(execFile);
+/** Keep file access outside the controller sandbox, under the existing CLI auth contract. */
+async function readDispatchSpaceFile(input) {
+	const env = input.env ?? process.env;
+	if (env["OPENMELD_DISPATCH_RUNTIME_MODE"] !== "dispatch-owned-runtime") throw new Error("Space file tools require an active OpenMeld dispatch runtime.");
+	const context = readDispatchSpaceActionContextFromEnv(env);
+	const command = resolveDispatchSpaceActionMcpServer(env);
+	if (!command) throw new Error("No active OpenMeld dispatch file reader was found.");
+	const fileId = spaceFileEntryIdSchema.parse(input.fileId);
+	const revision = spaceFileRevisionNumberSchema.optional().parse(input.revision);
+	const args = [
+		"space",
+		"files",
+		"read",
+		"--profile",
+		context.targetProfileId,
+		"--json",
+		"--view",
+		"agent",
+		...revision === void 0 ? [] : ["--revision", String(revision)],
+		"--",
+		context.spaceId,
+		fileId
+	];
+	const { stdout } = await execFileAsync(command.commandPath, args, {
+		env,
+		encoding: "utf8",
+		maxBuffer: 8 * 1024 * 1024,
+		timeout: 3e4
+	}).catch((error) => {
+		if (error && typeof error === "object" && "stdout" in error && typeof error.stdout === "string") {
+			let value;
+			try {
+				value = JSON.parse(error.stdout);
+			} catch {}
+			const parsed = cliJsonErrorEnvelopeSchema.safeParse(value);
+			if (parsed.success) throw new Error(JSON.stringify(parsed.data), { cause: error });
+		}
+		throw error;
+	});
+	const result = readSpaceFileTextResponseSchema.parse(JSON.parse(stdout));
+	if (result.file.spaceId !== context.spaceId || result.file.id !== fileId || revision !== void 0 && result.revision !== revision) throw new Error("The Space file response does not match the requested file revision.");
+	return result;
+}
+//#endregion
+//#region src/space/dispatch-history-read.ts
+/** Read the current Wake's bounded Space history through the existing member API. */
+async function readDispatchSpaceHistory(env = process.env) {
+	if (env["OPENMELD_DISPATCH_RUNTIME_MODE"] !== "dispatch-owned-runtime") throw new Error("Space history tools require an active OpenMeld dispatch runtime.");
+	const context = readDispatchSpaceActionContextFromEnv(env);
+	const profile = await requireOpenMeldProfile({
+		openMeldProfileId: context.targetProfileId,
+		persistSelection: false,
+		authAction: "reading the current Wake's Space history"
+	});
+	if (profile.openMeldProfileId !== context.targetProfileId || profile.profileKind !== "agent") throw new Error("The Space history reader does not match the current Agent.");
+	const result = await createCliSpaceApi(await resolveBaseUrl()).listSignals({
+		spaceId: context.spaceId,
+		requestContext: buildOpenMeldRequestContextFromProfile({ openMeldProfile: profile }),
+		query: {
+			aroundSignalId: context.sourceEventId,
+			beforeCount: 20,
+			afterCount: 0,
+			kinds: ["text"]
+		}
+	});
+	const current = readDispatchSpaceActionContextFromEnv(env);
+	if (current.contextId !== context.contextId || current.nonce !== context.nonce || current.spaceId !== context.spaceId || current.sourceEventId !== context.sourceEventId || current.targetProfileId !== context.targetProfileId) throw new Error("The dispatch context changed during the Space history read.");
+	const output = dispatchSpaceHistoryResultSchema.parse({
+		spaceId: context.spaceId,
+		sourceSignalId: context.sourceEventId,
+		beforeCount: 20,
+		afterCount: 0,
+		signals: result.signals,
+		nextCursor: result.nextCursor
+	});
+	const signals = output.signals.map((signal) => signalTextEnvelopeSchema.parse(signal));
+	if (signals.some((signal) => signal.spaceId !== context.spaceId)) throw new Error("The Space history response does not match the current Space.");
+	return {
+		...output,
+		signals
+	};
+}
+//#endregion
+//#region src/space/dispatch-read-result.ts
+const PAGE_BYTES = 8 * 1024;
+const SNAPSHOT_BYTES = 32 * 1024 * 1024;
+const SNAPSHOT_COUNT = 4;
+var DispatchReadResults = class {
+	#snapshots = /* @__PURE__ */ new Map();
+	#bytes = 0;
+	wrap(result) {
+		if (result.isError) return result;
+		const value = result.structuredContent ?? JSON.parse(result.content.map((item) => item.text).join("\n"));
+		const complete = dispatchSpaceReadResultSchema.parse({ result: value });
+		if (Buffer.byteLength(JSON.stringify(complete)) <= PAGE_BYTES) return this.#result(complete);
+		const bytes = Buffer.from(JSON.stringify(value));
+		if (bytes.length > SNAPSHOT_BYTES) throw new Error("The read exceeds this Wake's in-memory result budget. Request a smaller source; no local file was created.");
+		while (this.#snapshots.size >= SNAPSHOT_COUNT || this.#bytes + bytes.length > SNAPSHOT_BYTES) {
+			const oldest = this.#snapshots.keys().next().value;
+			if (oldest === void 0) break;
+			this.#bytes -= this.#snapshots.get(oldest)?.bytes.length ?? 0;
+			this.#snapshots.delete(oldest);
+		}
+		const resultId = randomUUID();
+		this.#snapshots.set(resultId, {
+			bytes,
+			offsets: /* @__PURE__ */ new Set([0])
+		});
+		this.#bytes += bytes.length;
+		return this.read(resultId, 0);
+	}
+	read(resultId, offset) {
+		const snapshot = this.#snapshots.get(resultId);
+		if (!snapshot?.offsets.has(offset)) throw new Error("This result or offset is unavailable in the current tool invocation. Use a returned nextOffset, or read the source again; do not open a local file.");
+		const { bytes } = snapshot;
+		let end = Math.min(offset + PAGE_BYTES, bytes.length);
+		while (true) {
+			while (end < bytes.length && isUtf8Continuation(bytes[end])) end -= 1;
+			const nextOffset = end === bytes.length ? null : end;
+			const value = dispatchSpaceReadResultSchema.parse({ page: {
+				resultId,
+				offset,
+				nextOffset,
+				totalBytes: bytes.length,
+				text: bytes.subarray(offset, end).toString("utf8")
+			} });
+			if (Buffer.byteLength(JSON.stringify(value)) <= PAGE_BYTES) {
+				if (nextOffset !== null) snapshot.offsets.add(nextOffset);
+				return this.#result(value);
+			}
+			end = offset + Math.floor((end - offset) * .8);
+		}
+	}
+	clear() {
+		this.#snapshots.clear();
+		this.#bytes = 0;
+	}
+	#result(value) {
+		return {
+			structuredContent: value,
+			content: [{
+				type: "text",
+				text: JSON.stringify(value)
+			}]
+		};
+	}
+};
+function isUtf8Continuation(byte) {
+	return byte !== void 0 && byte >= 128 && byte < 192;
+}
+//#endregion
+//#region src/space/dispatch-task.ts
+async function listDispatchSpaceTasks(phase, env = process.env) {
+	return await withDispatchTaskContext(async ({ actionContext, api, requestContext }) => await api.listTasks({
+		spaceId: actionContext.spaceId,
+		requestContext,
+		...phase ? { phase } : {}
+	}), env);
+}
+async function createDispatchSpaceTask(body, env = process.env) {
+	return await withDispatchTaskContext(async ({ actionContext, api, requestContext }) => await api.createTask({
+		spaceId: actionContext.spaceId,
+		requestContext,
+		body: createSpaceTaskBodySchema.parse({
+			...body,
+			operationId: crypto.randomUUID(),
+			sourceSignalId: actionContext.sourceEventId,
+			assigneeProfileId: body.assigneeProfileId === void 0 ? actionContext.targetProfileId : body.assigneeProfileId
+		})
+	}), env);
+}
+async function mutateDispatchSpaceTask(input, env = process.env) {
+	const taskId = spaceTaskIdSchema.parse(input.taskId);
+	const body = mutateSpaceTaskBodySchema.parse({
+		...input.body,
+		operationId: crypto.randomUUID()
+	});
+	return await withDispatchTaskContext(async ({ actionContext, api, requestContext }) => await api.mutateTask({
+		spaceId: actionContext.spaceId,
+		requestContext,
+		taskId,
+		body
+	}), env);
+}
+async function withDispatchTaskContext(operation, env) {
+	if (env["OPENMELD_DISPATCH_RUNTIME_MODE"] !== "dispatch-owned-runtime") throw new Error("Space Task tools require an active OpenMeld dispatch runtime.");
+	const actionContext = readDispatchSpaceActionContextFromEnv(env);
+	const profile = await requireOpenMeldProfile({
+		openMeldProfileId: actionContext.targetProfileId,
+		persistSelection: false,
+		authAction: "working with Tasks in the current OpenMeld Space"
+	});
+	if (profile.openMeldProfileId !== actionContext.targetProfileId || profile.profileKind !== "agent") throw new Error("The Space Task actor does not match the current Agent.");
+	const result = await operation({
+		actionContext,
+		api: createCliSpaceApi(await resolveBaseUrl()),
+		requestContext: buildOpenMeldRequestContextFromProfile({ openMeldProfile: profile })
+	});
+	const current = readDispatchSpaceActionContextFromEnv(env);
+	if (current.contextId !== actionContext.contextId || current.nonce !== actionContext.nonce || current.spaceId !== actionContext.spaceId || current.sourceEventId !== actionContext.sourceEventId || current.targetProfileId !== actionContext.targetProfileId) throw new Error("The dispatch context changed during the Space Task action.");
+	return result;
+}
+//#endregion
+//#region src/space/dispatch-working-copy.ts
+const run = promisify(execFile);
+async function runDispatchWorkingCopy(action, resolution, env = process.env) {
+	const context = readDispatchSpaceActionContextFromEnv(env);
+	const command = resolveDispatchSpaceActionMcpServer(env);
+	if (!(command && context.workingCopyId)) throw new Error("This Wake has no prepared working copy.");
+	const { stdout } = await run(command.commandPath, [
+		"space",
+		"files",
+		"working-copy",
+		action,
+		"--profile",
+		context.targetProfileId,
+		"--json",
+		"--view",
+		"agent",
+		...action === "resolve" ? [
+			"--file-id",
+			resolution?.fileId ?? "",
+			"--revision",
+			String(resolution?.revision ?? 0)
+		] : [],
+		"--",
+		context.spaceId,
+		context.workingCopyId
+	], {
+		encoding: "utf8",
+		env,
+		maxBuffer: 1024 * 1024,
+		timeout: 12e4
+	}).catch((error) => {
+		if (error && typeof error === "object" && "stdout" in error && typeof error.stdout === "string") {
+			let value;
+			try {
+				value = JSON.parse(error.stdout);
+			} catch {}
+			const parsed = cliJsonErrorEnvelopeSchema.safeParse(value);
+			if (parsed.success) throw new Error(JSON.stringify(parsed.data), { cause: error });
+		}
+		throw error;
+	});
+	return spaceWorkingCopyResultSchema.parse(JSON.parse(stdout));
+}
+//#endregion
+//#region src/space/action-mcp-server.ts
+const DISPATCH_SPACE_TOOL_INSTRUCTIONS = "Use read_history for the bounded text history around the current Wake, and read_file for shared text files in the current Space. Use Space Task tools only when a clear deliverable needs durable ownership, progress, review, or later closure; questions and tiny same-turn actions stay in Messages. Task operations are non-final. Then choose exactly one permitted final OpenMeld Space Action: reply for an answer, limitation, error explanation, or request for help; stay_silent only when no public communication is appropriate. Do not create a Task just to acknowledge a message. Parameter validation errors record no action and may be corrected. Use read_receipt to reconcile an unknown outcome before resending. Private assistant output is not posted to the Space.";
+/** Every carrier uses the same schemas, validation, authority and recorder. */
+var DispatchSpaceTools = class {
+	tools = [];
+	deliveryOnly;
+	#env;
+	#context;
+	#handlers = /* @__PURE__ */ new Map();
+	#closed = false;
+	#readResults = new DispatchReadResults();
+	constructor(env) {
+		this.#env = Object.freeze({ ...env });
+		this.#context = readDispatchSpaceActionContextForReceiptFromEnv(this.#env);
+		this.deliveryOnly = isDispatchSpaceActionDeliveryOnly(this.#env);
+	}
+	registerTool(name, config, handler) {
+		if (this.deliveryOnly && ![
+			"reply",
+			"stay_silent",
+			"read_receipt"
+		].includes(name)) return;
+		const inputSchema = config.inputSchema instanceof z.ZodObject ? config.inputSchema : z.strictObject(config.inputSchema);
+		const pagedRead = [
+			"read_history",
+			"read_file",
+			"list_tasks"
+		].includes(name);
+		this.tools.push({
+			...config,
+			name,
+			inputSchema,
+			...pagedRead ? {
+				outputSchema: dispatchSpaceReadResultSchema,
+				description: `${config.description} Small reads return result; large reads return page. Continue with read_result using page.resultId and page.nextOffset; no local file is needed.`
+			} : {}
+		});
+		this.#handlers.set(name, (args) => {
+			const parsed = inputSchema.safeParse(args);
+			if (!parsed.success) return executeSpaceAction(() => {
+				throw new DispatchSpaceActionRejectedError("space_action.invalid_input", parsed.error.message);
+			}, this.#env);
+			return handler(parsed.data);
+		});
+	}
+	async call(name, args) {
+		const context = readDispatchSpaceActionContextForReceiptFromEnv(this.#env);
+		if (this.#closed || context.contextId !== this.#context.contextId || context.nonce !== this.#context.nonce) return executeSpaceAction(() => {
+			throw new DispatchSpaceActionClosedError("space_action.context_mismatch", "This tool invocation no longer owns the active Wake. Do not retry through another transport.");
+		}, this.#env);
+		const handler = this.#handlers.get(name);
+		if (!handler) return executeSpaceAction(() => {
+			throw new DispatchSpaceActionRejectedError("space_action.not_allowed", "This tool is not available in the current invocation. Final communication uses reply or stay_silent, subject to the existing Space policy.");
+		}, this.#env);
+		const pagedRead = [
+			"read_history",
+			"read_file",
+			"list_tasks"
+		].includes(name);
+		if (pagedRead || name === "read_result") try {
+			readDispatchSpaceActionContextFromEnv(this.#env);
+			const result = await handler(args);
+			const active = readDispatchSpaceActionContextFromEnv(this.#env);
+			if (this.#closed || active.contextId !== this.#context.contextId || active.nonce !== this.#context.nonce) throw new Error("The Wake changed or closed during this read. No result is available.");
+			return pagedRead ? this.#readResults.wrap(result) : result;
+		} catch (error) {
+			return {
+				isError: true,
+				content: [{
+					type: "text",
+					text: error instanceof Error ? error.message : "The Space read failed."
+				}]
+			};
+		}
+		return await handler(args);
+	}
+	registerResultReader() {
+		this.registerTool("read_result", {
+			title: "Continue reading a large Space tool result",
+			description: "Read the next page of a large read_history, read_file, or list_tasks result. Pass the returned resultId and nextOffset exactly; append page.text in order to reconstruct the complete JSON. No local path or shell is needed. The snapshot belongs only to this active Wake and tool connection; after expiry or eviction, read the source again. Does not publish or repeat an operation.",
+			inputSchema: dispatchSpaceReadResultRequestSchema,
+			outputSchema: dispatchSpaceReadResultSchema,
+			annotations: {
+				readOnlyHint: true,
+				destructiveHint: false,
+				idempotentHint: true,
+				openWorldHint: false
+			}
+		}, async ({ resultId, offset }) => this.#readResults.read(resultId, offset));
+	}
+	close() {
+		this.#closed = true;
+		this.#readResults.clear();
+	}
+};
+function createDispatchSpaceTools(input = {}) {
+	const env = Object.freeze({ ...input.env ?? process.env });
+	const server = new DispatchSpaceTools(env);
+	const projectShell = readDispatchSpaceActionContextForReceiptFromEnv(env).projectShell;
+	if (projectShell) server.registerTool("project_shell", {
+		title: "Run a command in this task's project worktree",
+		description: "Run one Bash command inside this task's isolated project container. Only its private worktree is mounted. The container has no network, host credentials, or Docker socket. This tool does not submit the final Space action.",
+		inputSchema: dispatchProjectShellInputSchema,
+		outputSchema: dispatchProjectShellResultSchema,
+		annotations: {
+			readOnlyHint: false,
+			destructiveHint: true,
+			idempotentHint: false,
+			openWorldHint: false
+		}
+	}, async ({ command }) => {
+		try {
+			const context = readDispatchSpaceActionContextForReceiptFromEnv(env);
+			if (!context.projectShell || context.projectShell.executionContextId !== projectShell.executionContextId || context.projectShell.boundaryRoot !== projectShell.boundaryRoot || context.projectShell.ledgerRootPath !== projectShell.ledgerRootPath || context.projectShell.workspacePath !== projectShell.workspacePath || context.projectShell.runtime.binary !== projectShell.runtime.binary || context.projectShell.runtime.engineIdentity !== projectShell.runtime.engineIdentity || context.projectShell.runtime.kind !== projectShell.runtime.kind) throw new Error("claude_project.context_mismatch");
+			const result = dispatchProjectShellResultSchema.parse(await runExecutionContextWorkspaceProjectShell({
+				ledgerRootPath: projectShell.ledgerRootPath,
+				contextId: projectShell.executionContextId,
+				dispatchId: context.dispatchId,
+				attemptId: context.attemptId,
+				command,
+				runtime: projectShell.runtime,
+				boundaryRoot: projectShell.boundaryRoot,
+				workspacePath: projectShell.workspacePath
+			}));
+			return {
+				structuredContent: result,
+				content: [{
+					type: "text",
+					text: JSON.stringify(result)
+				}]
+			};
+		} catch (error) {
+			return {
+				isError: true,
+				content: [{
+					type: "text",
+					text: error instanceof Error && error.message.startsWith("claude_project.") ? error.message.split(":")[0] ?? "claude_project.execution_failed" : "claude_project.execution_failed"
+				}]
+			};
+		}
+	});
+	server.registerTool("working_copy", {
+		title: "Save or inspect this handoff's files",
+		description: "Inspect or commit this handoff's files; reconcile retries an unknown save. On conflict, refresh downloads the shared version, then status shows its path and revision. Merge it into the original working file, then resolve with fileId and incoming revision before committing again. No automatic merge or overwrite. Does not deliver or close the Wake. No Space, profile or path overrides.",
+		inputSchema: {
+			action: z.enum([
+				"status",
+				"commit",
+				"reconcile",
+				"refresh",
+				"resolve"
+			]),
+			fileId: z.string().optional(),
+			revision: z.number().int().positive().optional()
+		}
+	}, async ({ action, fileId, revision }) => {
+		try {
+			return { content: [{
+				type: "text",
+				text: JSON.stringify(await runDispatchWorkingCopy(action, {
+					fileId,
+					revision
+				}, env))
+			}] };
+		} catch (error) {
+			return {
+				isError: true,
+				content: [{
+					type: "text",
+					text: error instanceof Error ? error.message : String(error)
+				}]
+			};
+		}
+	});
+	server.registerTool("read_history", {
+		title: "Read the current Wake's Space history",
+		description: "Read up to 20 text messages before the current Wake, plus its source message. Space, Agent identity and source are fixed by the active dispatch. Use this instead of terminal CLI history. This read does not submit a reply or close the Wake.",
+		inputSchema: dispatchSpaceHistoryRequestSchema,
+		annotations: {
+			readOnlyHint: true,
+			destructiveHint: false,
+			idempotentHint: true,
+			openWorldHint: false
+		}
+	}, async () => {
+		try {
+			const result = await readDispatchSpaceHistory(env);
+			return {
+				structuredContent: result,
+				content: [{
+					type: "text",
+					text: JSON.stringify(result)
+				}]
+			};
+		} catch (error) {
+			return {
+				isError: true,
+				content: [{
+					type: "text",
+					text: error instanceof Error ? error.message : String(error)
+				}]
+			};
+		}
+	});
+	server.registerTool("read_file", {
+		title: "Read a file in the current OpenMeld Space",
+		description: "Read a shared text file as the Agent in the current Wake. Use this for attached CSV, text, Markdown, or JSON files instead of running the CLI in a terminal. Pass the attachment's file ID and revision. This is a context read; it does not submit a reply or close the Wake.",
+		inputSchema: {
+			fileId: spaceFileEntryIdSchema,
+			revision: spaceFileRevisionNumberSchema.optional()
+		},
+		annotations: {
+			readOnlyHint: true,
+			destructiveHint: false,
+			idempotentHint: true,
+			openWorldHint: false
+		}
+	}, async (input) => {
+		try {
+			const result = await readDispatchSpaceFile({
+				...input,
+				env
+			});
+			return { content: [{
+				type: "text",
+				text: JSON.stringify(result)
+			}] };
+		} catch (error) {
+			return {
+				content: [{
+					type: "text",
+					text: error instanceof Error ? error.message : String(error)
+				}],
+				isError: true
+			};
+		}
+	});
+	server.registerTool("list_tasks", {
+		title: "List Tasks in the current OpenMeld Space",
+		description: "Read durable collaboration Tasks for this Space. Use the returned revision before changing a Task. Task phase is collaboration state, not Agent execution truth.",
+		inputSchema: { phase: z.enum([
+			"to_do",
+			"in_progress",
+			"in_review",
+			"done",
+			"canceled"
+		]).optional() },
+		annotations: {
+			readOnlyHint: true,
+			destructiveHint: false,
+			idempotentHint: true,
+			openWorldHint: false
+		}
+	}, async ({ phase }) => executeTaskAction(() => listDispatchSpaceTasks(phase, env)));
+	server.registerTool("create_task", {
+		title: "Create a Task from the current Space message",
+		description: "Create a durable Task only for a clear deliverable that needs ownership, progress, review, or later closure. The source message and Space are fixed by this Wake. The Task is assigned to the current Agent by default and remains To do until start_task is called.",
+		inputSchema: {
+			title: z.string().trim().min(1).max(200),
+			description: z.string().trim().min(1).max(8e3).nullable().optional(),
+			completionConditions: z.array(z.string().trim().min(1).max(500)).max(12).optional(),
+			assigneeProfileId: openMeldRuntimeProfileIdSchema.nullable().optional(),
+			reviewerProfileId: openMeldRuntimeProfileIdSchema.nullable().optional()
+		},
+		outputSchema: spaceTaskMutationReceiptSchema,
+		annotations: {
+			readOnlyHint: false,
+			destructiveHint: false,
+			idempotentHint: false,
+			openWorldHint: false
+		}
+	}, async (body) => executeTaskAction(() => createDispatchSpaceTask(body, env)));
+	server.registerTool("start_task", {
+		title: "Mark a Space Task in progress",
+		description: "Record that the current assigned Agent has begun advancing this Task. This changes collaboration state and does not start a separate Agent execution.",
+		inputSchema: {
+			taskId: spaceTaskIdSchema,
+			expectedRevision: z.number().int().min(1)
+		},
+		outputSchema: spaceTaskMutationReceiptSchema,
+		annotations: {
+			readOnlyHint: false,
+			destructiveHint: false,
+			idempotentHint: false,
+			openWorldHint: false
+		}
+	}, async ({ expectedRevision, taskId }) => executeTaskAction(() => mutateDispatchSpaceTask({
+		taskId,
+		body: {
+			action: "mark_in_progress",
+			expectedRevision
+		}
+	}, env)));
+	server.registerTool("submit_task_result", {
+		title: "Submit a result for a Space Task",
+		description: "Submit the concrete result and verification for an in-progress Task. A Task with a reviewer moves to In review; otherwise the stated completion boundary moves it to Done. The Space delivers the review handoff to the reviewer.",
+		inputSchema: {
+			taskId: spaceTaskIdSchema,
+			expectedRevision: z.number().int().min(1),
+			summary: z.string().trim().min(1).max(8e3)
+		},
+		outputSchema: spaceTaskMutationReceiptSchema,
+		annotations: {
+			readOnlyHint: false,
+			destructiveHint: false,
+			idempotentHint: false,
+			openWorldHint: false
+		}
+	}, async ({ expectedRevision, summary, taskId }) => executeTaskAction(() => mutateDispatchSpaceTask({
+		taskId,
+		body: {
+			action: "submit_result",
+			expectedRevision,
+			summary
+		}
+	}, env)));
+	server.registerTool("review_task", {
+		title: "Review a Space Task result",
+		description: "Accept the exact result you read or request specific changes as this Task's reviewer. Pass that result's resultRevision as expectedResultRevision and the Task's revision as expectedRevision. A conflict requires reading the current Task and deciding again. Change requests require feedback. The Space delivers review and rework handoffs. Agent-to-Agent rework stops for a human decision after two automatic rounds.",
+		inputSchema: {
+			taskId: spaceTaskIdSchema,
+			expectedRevision: z.number().int().min(1),
+			expectedResultRevision: z.number().int().min(1),
+			decision: z.enum(["accepted", "changes_requested"]),
+			feedback: z.string().trim().min(1).max(8e3).nullable().optional()
+		},
+		outputSchema: spaceTaskMutationReceiptSchema,
+		annotations: {
+			readOnlyHint: false,
+			destructiveHint: false,
+			idempotentHint: false,
+			openWorldHint: false
+		}
+	}, async ({ decision, expectedRevision, expectedResultRevision, feedback, taskId }) => executeTaskAction(() => mutateDispatchSpaceTask({
+		taskId,
+		body: {
+			action: "review",
+			expectedRevision,
+			expectedResultRevision,
+			decision,
+			...feedback === void 0 ? {} : { feedback }
+		}
+	}, env)));
+	server.registerTool("cancel_task", {
+		title: "Cancel a Space Task",
+		description: "Cancel a Task when its accepted commitment should no longer be done. Cancellation fences later Task progress; it does not by itself prove that an Agent execution stopped.",
+		inputSchema: {
+			taskId: spaceTaskIdSchema,
+			expectedRevision: z.number().int().min(1),
+			reason: z.string().trim().min(1).max(1e3)
+		},
+		outputSchema: spaceTaskMutationReceiptSchema,
+		annotations: {
+			readOnlyHint: false,
+			destructiveHint: false,
+			idempotentHint: false,
+			openWorldHint: false
+		}
+	}, async ({ expectedRevision, reason, taskId }) => executeTaskAction(() => mutateDispatchSpaceTask({
+		taskId,
+		body: {
+			action: "cancel",
+			expectedRevision,
+			reason
+		}
+	}, env)));
+	server.registerTool("reply", {
+		title: "Reply in the current OpenMeld Space",
+		description: "Record the exact final public message for the active Wake: answers, known limitations, errors, and requests for help all belong here. Use real newlines. No shell, local repository, CLI, or Skill is needed to explain that you cannot complete a task. Omit recipient fields for a plain reply; use full Profile IDs from this Wake's send target reference when addressing recipients. Correct invalid arguments and retry; do not bypass denials or blindly resend an unknown outcome.",
+		inputSchema: {
+			message: z.string().min(1),
+			files: z.array(spaceMessageFileReferenceSchema).max(10).optional(),
+			mentionTargets: z.array(z.string().min(1)).optional(),
+			referenceTargets: z.array(z.string().min(1)).optional(),
+			wakeTargets: z.array(z.string().min(1)).optional()
+		},
+		outputSchema: dispatchSpaceActionToolResultSchema,
+		annotations: {
+			destructiveHint: false,
+			idempotentHint: false,
+			openWorldHint: false,
+			readOnlyHint: false
+		}
+	}, async ({ files, mentionTargets, message, referenceTargets, wakeTargets }) => executeSpaceAction(() => recordDispatchSpaceReply({
+		env,
+		files,
+		mentionTargets,
+		referenceTargets,
+		text: message,
+		wakeTargets
+	}), env));
+	server.registerTool("stay_silent", {
+		title: "Stay silent in the current OpenMeld Space",
+		description: "Record that the active OpenMeld Wake intentionally needs no public reply. Use this only after deciding that silence is the correct final outcome.",
+		inputSchema: { reason: z.string().min(1) },
+		outputSchema: dispatchSpaceActionToolResultSchema,
+		annotations: {
+			destructiveHint: false,
+			idempotentHint: false,
+			openWorldHint: false,
+			readOnlyHint: false
+		}
+	}, async ({ reason }) => executeSpaceAction(() => recordDispatchSpaceSilent({
+		reason,
+		env
+	}), env));
+	server.registerResultReader();
+	server.registerTool("read_receipt", {
+		title: "Check this Wake's recorded final action",
+		description: "Reconcile an uncertain final tool result without posting, replacing, or repeating the action. A saved receipt is a local proposal, not confirmation of publication. A missing record is an observation, not permission to bypass a denial or expiry.",
+		inputSchema: {},
+		annotations: {
+			readOnlyHint: true,
+			destructiveHint: false,
+			idempotentHint: true,
+			openWorldHint: false
+		}
+	}, async () => {
+		const record = readDispatchSpaceActionRecord({ context: readDispatchSpaceActionContextForReceiptFromEnv(env) });
+		if (record.status === "loaded") return await executeSpaceAction(() => record.record, env);
+		if (record.status === "missing") return { content: [{
+			type: "text",
+			text: "No local final action record is present. Correct invalid arguments and use a permitted final tool only while this Wake is still authorized. This read does not reserve a write or override a denial."
+		}] };
+		return executeSpaceAction(() => {
+			throw new Error("The existing final action record cannot be verified. Do not overwrite it or resend through another transport.");
+		}, env);
+	});
+	return server;
+}
+function createSpaceActionMcpServer() {
+	const context = readDispatchSpaceActionContextForReceiptFromEnv();
+	const tools = createDispatchSpaceTools();
+	const server = new McpServer({
+		name: "openmeld-dispatch-space-action",
+		version: "1.0.0"
+	}, { instructions: DISPATCH_SPACE_TOOL_INSTRUCTIONS });
+	for (const { name, ...definition } of tools.tools) server.registerTool(name, definition, async (args) => {
+		try {
+			const active = readDispatchSpaceActionContextForReceiptFromEnv();
+			if (active.contextId !== context.contextId || active.nonce !== context.nonce) throw new DispatchSpaceActionClosedError("space_action.context_mismatch", "This MCP server cannot be rebound to another Wake.");
+			return await tools.call(name, args);
+		} catch (error) {
+			return executeSpaceAction(() => {
+				throw error;
+			});
+		}
+	});
+	server.server.onclose = () => tools.close();
+	return server;
+}
+async function runSpaceActionMcpServer() {
+	readDispatchSpaceActionContextForReceiptFromEnv();
+	await createSpaceActionMcpServer().connect(new StdioServerTransport());
+}
+async function executeSpaceAction(action, env = process.env) {
+	try {
+		const context = readDispatchSpaceActionContextForReceiptFromEnv(env);
+		const record = await action();
+		if (record.contextId !== context.contextId || record.nonce !== context.nonce) throw new DispatchSpaceActionClosedError("space_action.context_mismatch", "The saved action does not match the current dispatch context.");
+		const contextState = Date.now() > context.expiresAtMs ? "expired" : "active";
+		return {
+			structuredContent: dispatchSpaceActionToolResultSchema.parse({ receipt: {
+				status: "proposal_saved_locally",
+				actionType: record.action.type,
+				attemptId: context.attemptId,
+				contextId: context.contextId,
+				dispatchId: context.dispatchId,
+				recordedAtMs: record.createdAtMs,
+				contextState,
+				coordinatorAcceptance: "unconfirmed",
+				publication: "unconfirmed"
+			} }),
+			content: [{
+				type: "text",
+				text: `Local proposal saved (receipt: proposal_saved_locally, action: ${record.action.type}). OpenMeld has recorded this unpublished Space action proposal on this computer. ${contextState === "expired" ? "The local context has expired. This receipt identifies the existing record and does not extend action authority. " : ""}Coordinator acceptance and Space publication are NOT yet confirmed; do not report it as posted.`
+			}]
+		};
+	} catch (error) {
+		if (error instanceof DispatchSpaceActionRejectedError) return {
+			structuredContent: dispatchSpaceActionToolResultSchema.parse({ receipt: {
+				status: "rejected_before_recording",
+				reasonCode: error.reasonCode,
+				coordinatorAcceptance: "unconfirmed",
+				publication: "unconfirmed"
+			} }),
+			content: [{
+				type: "text",
+				text: `Action rejected (receipt: rejected_before_recording, reason: ${error.reasonCode}). This call did not record an action. ${error.message} ${error.reasonCode === "space_action.invalid_input" ? "Correct the indicated arguments and call the same permitted tool again. " : ""}Any earlier records are preserved; Coordinator acceptance and Space publication are unconfirmed.`
+			}],
+			isError: true
+		};
+		if (error instanceof DispatchSpaceActionClosedError) return {
+			structuredContent: dispatchSpaceActionToolResultSchema.parse({ receipt: {
+				status: "rejected_closed",
+				reasonCode: error.reasonCode,
+				coordinatorAcceptance: "unconfirmed",
+				publication: "unconfirmed"
+			} }),
+			content: [{
+				type: "text",
+				text: `Action rejected (receipt: rejected_closed, reason: ${error.reasonCode}). ${error.message} New actions are not permitted in this context. Existing records are preserved; Coordinator acceptance and Space publication are unconfirmed.`
+			}],
+			isError: true
+		};
+		return {
+			structuredContent: dispatchSpaceActionToolResultSchema.parse({ receipt: {
+				status: "outcome_unknown",
+				reasonCode: "space_action.recording_outcome_unknown",
+				coordinatorAcceptance: "unconfirmed",
+				publication: "unconfirmed"
+			} }),
+			content: [{
+				type: "text",
+				text: `Action receipt unavailable (receipt: outcome_unknown). ${error instanceof Error ? error.message : String(error)} Existing records are preserved; Coordinator acceptance and Space publication are unconfirmed.`
+			}],
+			isError: true
+		};
+	}
+}
+async function executeTaskAction(action) {
+	try {
+		const result = await action();
+		return {
+			structuredContent: result,
+			content: [{
+				type: "text",
+				text: JSON.stringify(result)
+			}]
+		};
+	} catch (error) {
+		return {
+			isError: true,
+			content: [{
+				type: "text",
+				text: error instanceof Error ? error.message : String(error)
+			}]
+		};
+	}
+}
+//#endregion
 //#region src/organization-skills/cache.ts
 const CACHE_MARKER_FILENAME = ".openmeld-organization-skill.json";
 const DIRECTORY_READ_ONLY_MODE = 365;
@@ -2965,47 +5156,6 @@ async function downloadWorkingCopyFile(api, input) {
 	};
 }
 //#endregion
-//#region src/local-service/state/ledger-io.ts
-function createLedgerIo() {
-	return {
-		appendFile: async (filePath, content, encoding) => {
-			await mkdir(dirnamePath(filePath), { recursive: true });
-			await appendFile(filePath, content, { encoding });
-		},
-		copyFile: async (fromPath, toPath) => {
-			await mkdir(dirnamePath(toPath), { recursive: true });
-			await copyFile(fromPath, toPath);
-		},
-		mkdir: async (dirPath, options) => {
-			await mkdir(dirPath, options);
-		},
-		readFile: async (filePath, encoding) => {
-			return await readFile(filePath, encoding);
-		},
-		rename: async (fromPath, toPath) => {
-			await mkdir(dirnamePath(toPath), { recursive: true });
-			await rename(fromPath, toPath);
-		},
-		syncPath: async (fileOrDirectoryPath) => {
-			const isWindows = process.platform === "win32";
-			if (isWindows && (await stat(fileOrDirectoryPath)).isDirectory()) return;
-			const handle = await open(fileOrDirectoryPath, isWindows ? "r+" : "r");
-			try {
-				await handle.sync();
-			} finally {
-				await handle.close();
-			}
-		},
-		rm: async (filePath, options) => {
-			await rm(filePath, options);
-		},
-		writeFile: async (filePath, content, encoding) => {
-			await mkdir(dirnamePath(filePath), { recursive: true });
-			await writeFile(filePath, content, encoding);
-		}
-	};
-}
-//#endregion
 //#region src/local-service/file-access/space-working-copy.ts
 const hash = (bytes) => createHash("sha256").update(bytes).digest("hex");
 const O_NOFOLLOW_ANY = 536870912;
@@ -3508,6 +5658,6 @@ function isSameServiceIdentity(left, right) {
 	return left?.deviceId === right.deviceId && left.contractGeneration === right.contractGeneration;
 }
 //#endregion
-export { defaultManagedIntegrationPaths as C, uninstallAgentActivityIntegrations as D, resolveAgentActivityDispatcherCommand as E, AGENT_ACTIVITY_INTEGRATION_OWNER as S, readAgentActivityIntegrationStatus as T, readControllerTaskLifecycleOutboxHealth as _, fetchSpaceUpdates as a, resolveAgentActivityRouteForPath as b, downloadWorkingCopyFile as c, syncLocalAgentActivity as d, discoverLocalAgentSessionProviders as f, enqueueControllerTaskLifecycleEventWhileLocked as g, removeAgentActivityContextCache as h, recordRuntimeReportingSuccess as i, materializeOrganizationSkillRelease as l, readAgentActivityContextForPath as m, recordRuntimeReportingFailure as n, createSpaceWorkingCopies as o, recordOpenMeldCreatedLocalAgentSession as p, recordRuntimeReportingNotApplicable as r, createLedgerIo as s, readRuntimeReportingHealthState as t, startLocalAgentActivitySyncLoop as u, isAgentActivityRouteRegistered as v, installAgentActivityIntegrations as w, unregisterAgentActivityRoute as x, registerAgentActivityRoute as y };
+export { readControllerTaskLifecycleOutboxHealth as A, uninstallAgentActivityIntegrations as B, startLocalAgentActivitySyncLoop as C, readAgentActivityContextForPath as D, recordOpenMeldCreatedLocalAgentSession as E, AGENT_ACTIVITY_INTEGRATION_OWNER as F, defaultManagedIntegrationPaths as I, installAgentActivityIntegrations as L, registerAgentActivityRoute as M, resolveAgentActivityRouteForPath as N, removeAgentActivityContextCache as O, unregisterAgentActivityRoute as P, readAgentActivityIntegrationStatus as R, prepareClaudeProjectContainer as S, discoverLocalAgentSessionProviders as T, markExecutionContextWorkspaceInUse as _, fetchSpaceUpdates as a, releaseExecutionContextWorkspace as b, materializeOrganizationSkillRelease as c, runSpaceActionHelp as d, runSpaceActionReply as f, runSpaceActionWake as g, runSpaceActionTargets as h, recordRuntimeReportingSuccess as i, isAgentActivityRouteRegistered as j, enqueueControllerTaskLifecycleEventWhileLocked as k, createDispatchSpaceTools as l, runSpaceActionStatus as m, recordRuntimeReportingFailure as n, createSpaceWorkingCopies as o, runSpaceActionSilent as p, recordRuntimeReportingNotApplicable as r, downloadWorkingCopyFile as s, readRuntimeReportingHealthState as t, runSpaceActionMcpServer as u, prepareExecutionContextWorkspace as v, syncLocalAgentActivity as w, createLedgerIo as x, readExecutionContextWorkspace as y, resolveAgentActivityDispatcherCommand as z };
 
-//# sourceMappingURL=runtime-reporting-health-state-BgwfrH7f.js.map
+//# sourceMappingURL=runtime-reporting-health-state-DA-_vW-n.js.map