@gitroll/tacitt-cli 0.0.0-stage → 0.2.0

package/dist/cli.mjs

@@ -0,0 +1,1442 @@
+#!/usr/bin/env node
+import { _ as createExecutionPort, a as readAgentPresence, d as parseOptions, f as businessCommands, g as readStateDump, h as startupFailure, i as invoke, l as createRenderActivity, m as permissionDiagnostic, n as readOperation, o as createRuntime, p as longCommands, r as waitOperation, s as executorEventSchema, t as cancelOperation, u as helpText, v as startHost, y as traceStartup } from "./query-BA0XCwnR.mjs";
+import { et as makePrivateDirectory, tt as openPrivateFile } from "./src-k0Ya1Bri.mjs";
+import { Gt as safeField, Ht as ApplicationError, Wt as safeCode } from "./locate-U3-nkird.mjs";
+import { Qr as stateSchema, er as reviewTransportBytes, rt as readWorkspaceOutcomes, ut as resolveFailureLocation } from "./src-CC95LYYp.mjs";
+import { gt as isCoordinationBusy } from "./heap-BHcvxWCw.mjs";
+import { constants, createReadStream, write } from "node:fs";
+import { z } from "zod";
+import { lstat, mkdir, mkdtemp, open, readFile, readdir, realpath, rename, rm, writeFile } from "node:fs/promises";
+import { spawn } from "node:child_process";
+import { dirname, isAbsolute, join, resolve } from "node:path";
+import { createInterface } from "node:readline";
+import { fileURLToPath } from "node:url";
+import { createHash, randomUUID } from "node:crypto";
+import { setTimeout as setTimeout$1 } from "node:timers/promises";
+import { monitorEventLoopDelay, performance as performance$1 } from "node:perf_hooks";
+import { homedir } from "node:os";
+import open$1 from "open";
+import { parse, patch } from "@decimalturn/toml-patch";
+import { applyEdits, modify } from "jsonc-parser";
+//#region apps/cli/src/host-timing.ts
+function available(read) {
+	try {
+		return read();
+	} catch {
+		return null;
+	}
+}
+function sample() {
+	const monotonicMs = performance$1.now();
+	const epochMs = Date.now();
+	const loop = available(() => performance$1.eventLoopUtilization());
+	return {
+		monotonicMs,
+		epochMs,
+		processCpu: available(() => process.cpuUsage()),
+		threadCpu: available(() => process.threadCpuUsage()),
+		loop: loop && loop.active + loop.idle > 0 ? loop : null
+	};
+}
+function cpuDelta(current, previous) {
+	if (!current || !previous || current.user < previous.user || current.system < previous.system) return null;
+	return {
+		userMs: (current.user - previous.user) / 1e3,
+		systemMs: (current.system - previous.system) / 1e3
+	};
+}
+function loopDelta(current, previous) {
+	if (!current || !previous || current.active < previous.active || current.idle < previous.idle) return null;
+	const delta = available(() => performance$1.eventLoopUtilization(current, previous));
+	return delta ? {
+		activeMs: delta.active,
+		idleMs: delta.idle
+	} : null;
+}
+/** Existing-heartbeat observations only; callers keep the timer and shutdown lifetime. */
+function createHostTimingSampler(write = (line) => {
+	process.stderr.write(line);
+}) {
+	let previous = available(sample);
+	let detectedLags = 0;
+	let observationFailed = previous === null;
+	let emissionFailed = false;
+	return {
+		observe(summary) {
+			const current = available(sample);
+			const baseline = previous;
+			previous = current;
+			if (!current) observationFailed = true;
+			if (!current || !baseline) return;
+			const lagMs = current.monotonicMs - baseline.monotonicMs - 1e3;
+			if (lagMs <= 2e3) return;
+			detectedLags += 1;
+			const processCpu = cpuDelta(current.processCpu, baseline.processCpu);
+			const threadCpu = cpuDelta(current.threadCpu, baseline.threadCpu);
+			const loop = loopDelta(current.loop, baseline.loop);
+			const store = summary ? {
+				executor: summary.executor,
+				lastAccessId: summary.lastAccessId,
+				dequeuedAccessId: summary.dequeuedAccessId,
+				queueDepth: summary.queueDepth,
+				pending: summary.pending ? {
+					accessId: summary.pending.accessId,
+					operation: summary.pending.operation,
+					write: summary.pending.write,
+					phase: summary.pending.phase,
+					queueDepth: summary.pending.queueDepth,
+					queueMs: summary.pending.queueMs,
+					activeMs: summary.pending.activeMs,
+					phaseMs: summary.pending.phaseMs
+				} : null
+			} : null;
+			return {
+				event: "HOST_TIMER_LAG",
+				lagMs: Math.round(lagMs),
+				interval: {
+					monotonicStartMs: baseline.monotonicMs,
+					monotonicEndMs: current.monotonicMs,
+					epochStartMs: baseline.epochMs,
+					epochEndMs: current.epochMs
+				},
+				processCpu,
+				threadCpu,
+				loop,
+				availability: {
+					processCpu: processCpu !== null,
+					threadCpu: threadCpu !== null,
+					loop: loop !== null,
+					store: store !== null
+				},
+				store
+			};
+		},
+		unavailable() {
+			observationFailed = true;
+			previous = null;
+		},
+		emit(value) {
+			try {
+				write(JSON.stringify(value) + "\n");
+			} catch {
+				emissionFailed = true;
+			}
+		},
+		receipt: () => ({
+			detectedLags,
+			observationFailed,
+			emissionFailed
+		})
+	};
+}
+//#endregion
+//#region apps/cli/src/ownership-diagnostic.ts
+/** A failed diagnostic destination cannot change the inconclusive probe result. */
+function reportOwnershipCheckDeferred() {
+	try {
+		write(process.stderr.fd, `${JSON.stringify({
+			event: "HOST_OWNERSHIP_CHECK_DEFERRED",
+			code: "COORDINATION_BUSY"
+		})}\n`, (_error) => {});
+	} catch {}
+}
+async function serve(options, journeyId) {
+	let initializing;
+	let shutdownPhase = "application-and-account";
+	let stopping;
+	let host;
+	let ownerTimer;
+	let finishTimer;
+	let observedStore = void 0;
+	const timing = process.env["CI"] ? createHostTimingSampler() : void 0;
+	const timingTimer = process.env["CI"] ? setInterval(() => {
+		try {
+			let summary;
+			try {
+				summary = observedStore?.accessSummary();
+			} catch {
+				summary = void 0;
+			}
+			const lag = timing?.observe(summary);
+			if (lag) timing?.emit(lag);
+			if (summary?.pending && summary.pending.activeMs >= 2e3) timing?.emit({
+				event: "STORE_ACCESS_PENDING",
+				executor: summary.executor,
+				...summary.pending
+			});
+		} catch {
+			timing?.unavailable();
+		}
+	}, 1e3) : void 0;
+	timingTimer?.unref();
+	const loopDelay = process.env["CI"] ? monitorEventLoopDelay({ resolution: 20 }) : void 0;
+	loopDelay?.enable();
+	const stop = () => stopping ??= (async () => {
+		if (timingTimer) clearInterval(timingTimer);
+		if (loopDelay) try {
+			loopDelay.disable();
+			const ms = (nanoseconds) => Math.round(nanoseconds / 1e5) / 10;
+			timing?.emit({
+				event: "HOST_EVENT_LOOP_DELAY",
+				executor: runtime.store.accessSummary()?.executor,
+				maxMs: ms(loopDelay.max),
+				p99Ms: ms(loopDelay.percentile(99)),
+				meanMs: ms(loopDelay.mean),
+				timing: timing.receipt()
+			});
+		} catch {
+			timing?.unavailable();
+		}
+		const deadline = setTimeout(() => {
+			process.stderr.write(`${JSON.stringify({
+				event: "HOST_SHUTDOWN_FAILURE",
+				reason: "deadline",
+				phase: shutdownPhase
+			})}\n`);
+			process.exit(1);
+		}, 5e3);
+		if (ownerTimer) clearInterval(ownerTimer);
+		if (finishTimer) clearInterval(finishTimer);
+		host?.beginStop();
+		try {
+			await runtime.close();
+		} finally {
+			try {
+				await host?.stop();
+			} finally {
+				clearTimeout(deadline);
+			}
+		}
+	})();
+	const scheduleStop = async (code) => {
+		if (code) {
+			process.stderr.write(`${code}: this instance is stopping.\n`);
+			process.exitCode = 1;
+		}
+		setTimeout(() => {
+			stop().catch(stopFailed);
+		}, 100);
+	};
+	const runtime = await createRuntime(options, {
+		stopHost: scheduleStop,
+		settleStartup: async () => {
+			await initializing;
+		},
+		closeHost: async () => {
+			await host?.stop();
+		},
+		onClosePhase: (phase) => {
+			shutdownPhase = phase;
+		}
+	});
+	observedStore = runtime.store;
+	const stopFailed = (error) => {
+		process.stderr.write(`${JSON.stringify({
+			event: "HOST_SHUTDOWN_FAILURE",
+			reason: "rejection",
+			code: safeCode(error)
+		})}\n`);
+		process.exitCode = 1;
+	};
+	const onSignal = () => {
+		if (stopping) process.exit(130);
+		stop().catch(stopFailed);
+	};
+	try {
+		await runtime.application.getSensitiveTerms();
+		if (journeyId && !await runtime.application.journey?.get({ journeyId })) throw new ApplicationError("INVALID_TRANSITION");
+		traceStartup("host-start");
+		host = await startHost({
+			application: runtime.application,
+			account: runtime.account,
+			nativeInspection: runtime.nativeInspection,
+			agentPresence: (id) => readAgentPresence(runtime.stateDir, id),
+			onFatal: (code) => {
+				scheduleStop(code);
+			},
+			onPermissionFailure(error, stage) {
+				process.stderr.write(`${JSON.stringify({
+					event: "host.permission_check_failed",
+					code: safeCode(error),
+					stage,
+					cause: permissionDiagnostic(error)
+				})}\n`);
+			},
+			onServerFailure: (failure, error) => runtime.diagnostics.onHostFailure(failure, error),
+			webRoot: fileURLToPath(new URL("./web/", import.meta.url)),
+			...process.env["CI"] ? { currentViewStoreSummary: () => runtime.store.accessSummary() } : {},
+			...options.dev ? { devRoot: fileURLToPath(new URL("../../../", import.meta.url)) } : {}
+		});
+		traceStartup("host-ready");
+		let checking = false;
+		ownerTimer = setInterval(() => {
+			if (checking || stopping) return;
+			checking = true;
+			runtime.application.checkOwnership().catch((error) => {
+				if (isCoordinationBusy(error)) {
+					reportOwnershipCheckDeferred();
+					return;
+				}
+				return scheduleStop(safeCode(error));
+			}).finally(() => {
+				checking = false;
+			});
+		}, 1e3);
+		process.on("SIGINT", onSignal);
+		process.on("SIGTERM", onSignal);
+		if (journeyId) {
+			let endedAt;
+			finishTimer = setInterval(() => {
+				runtime.application.journey?.get({ journeyId }).then((journey) => {
+					endedAt = journey?.phase === "completed" || journey?.abandonedAt !== void 0 ? endedAt ?? Date.now() : void 0;
+					if (endedAt !== void 0 && Date.now() - endedAt >= 18e5) scheduleStop();
+				}).catch(() => {});
+			}, 6e4);
+			finishTimer.unref();
+			const url = new URL(host.url);
+			url.searchParams.set("view", "skill");
+			url.searchParams.set("journey", journeyId);
+			process.stdout.write(`${JSON.stringify({
+				ok: true,
+				event: "ready",
+				result: {
+					url: url.href,
+					journeyId
+				}
+			})}\n`);
+		} else {
+			process.stdout.write(`Open this private URL to review sessions:\n${host.url}\nBundle library: ${runtime.library.path}${runtime.library.source === "fallback" ? ` (fallback from ${runtime.library.fallbackFrom})` : ""}\nLocal diagnostic logs: ${join(runtime.stateDir, "diagnostics")}\n`);
+			initializing = runtime.application.initialize().catch((error) => {
+				if (stopping) {
+					process.stderr.write(`${JSON.stringify({
+						event: "host.initialization_interrupted",
+						code: safeCode(error)
+					})}\n`);
+					return;
+				}
+				return scheduleStop(safeCode(error));
+			});
+		}
+		if (!journeyId && !options["no-open"]) try {
+			await open$1(host.url, { wait: false });
+		} catch {
+			process.stderr.write("The browser could not be opened. Use the URL printed above.\n");
+		}
+		await new Promise((resolve) => {
+			const observe = setInterval(() => {
+				if (stopping) {
+					clearInterval(observe);
+					stopping.then(resolve, resolve);
+				}
+			}, 100);
+		});
+	} catch (error) {
+		await stop();
+		throw error;
+	} finally {
+		process.removeListener("SIGINT", onSignal);
+		process.removeListener("SIGTERM", onSignal);
+	}
+}
+//#endregion
+//#region apps/cli/src/package-identity.ts
+/** Release identity stays independent of producer/processing format versions. */
+const packageIdentity = Object.freeze(z.object({
+	name: z.literal("@gitroll/tacitt-cli"),
+	version: z.string().regex(/^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/)
+}).parse(JSON.parse(await readFile(new URL("../package.json", import.meta.url), "utf8"))));
+//#endregion
+//#region apps/cli/skills/tacitt/scripts/local-cli.mjs
+const fail = () => {
+	throw new Error("LOCAL_CLI_BINDING_INVALID");
+};
+const object$1 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const versionPattern = /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/;
+const digest$1 = (bytes) => createHash("sha256").update(bytes).digest("hex");
+async function regularFile(path, limit) {
+	const before = await lstat(path);
+	if (!before.isFile() || before.isSymbolicLink() || before.size > limit) fail();
+	const handle = await open(path, "r");
+	try {
+		const opened = await handle.stat();
+		if (opened.dev !== before.dev || opened.ino !== before.ino) fail();
+		const bytes = await handle.readFile();
+		const after = await lstat(path);
+		if (!after.isFile() || after.isSymbolicLink() || after.dev !== before.dev || after.ino !== before.ino || after.size !== before.size || after.mtimeMs !== before.mtimeMs || bytes.length !== before.size) fail();
+		return bytes;
+	} finally {
+		await handle.close();
+	}
+}
+async function packageFiles(root) {
+	const files = [];
+	let bytes = 0;
+	const visit = async (name, depth = 0) => {
+		if (depth > 16 || files.length >= 1e4) fail();
+		const path = join(root, name);
+		const info = await lstat(path);
+		if (info.isSymbolicLink()) fail();
+		if (info.isDirectory()) for (const child of (await readdir(path)).sort()) await visit(`${name}/${child}`, depth + 1);
+		else if (info.isFile()) {
+			const content = await regularFile(path, 536870912 - bytes);
+			bytes += content.length;
+			files.push([
+				name,
+				content.length,
+				digest$1(content)
+			]);
+		} else fail();
+	};
+	for (const name of [
+		"package.json",
+		"bin",
+		"dist",
+		"skills"
+	]) await visit(name);
+	return files;
+}
+/** Reads only the selected installed package; it never downloads or opens application state. */
+async function readLocalCliBinding(cliPath, expected) {
+	if (typeof cliPath !== "string" || !isAbsolute(cliPath) || cliPath.split("").some((character) => character.charCodeAt(0) < 32 || character.charCodeAt(0) === 127) || !object$1(expected) || expected.name !== "@gitroll/tacitt-cli" || typeof expected.version !== "string" || !versionPattern.test(expected.version)) fail();
+	const requested = await lstat(cliPath);
+	if (!requested.isFile() || requested.isSymbolicLink()) fail();
+	const executable = await realpath(cliPath);
+	const root = dirname(dirname(executable));
+	if (executable !== join(root, "bin", "tacitt.cjs")) fail();
+	const metadataBytes = await regularFile(join(root, "package.json"), 1048576);
+	const metadata = JSON.parse(metadataBytes.toString("utf8"));
+	if (!object$1(metadata) || metadata.name !== expected.name || metadata.version !== expected.version || !object$1(metadata.bin) || metadata.bin["tacitt"] !== "bin/tacitt.cjs") fail();
+	const files = await packageFiles(root);
+	if (!files.some(([name]) => name === "dist/cli.mjs") || !files.some(([name, , sha256]) => name === "package.json" && sha256 === digest$1(metadataBytes))) fail();
+	return {
+		schemaVersion: 1,
+		package: expected.name,
+		version: expected.version,
+		nodePath: await realpath(process.execPath),
+		cliPath: executable,
+		artifactSha256: digest$1(JSON.stringify(files))
+	};
+}
+//#endregion
+//#region apps/cli/src/skill-install/local.ts
+/** Only an explicit installed package can replace the public npx invocation. */
+async function localCliBinding(cliPath, identity) {
+	if (cliPath === void 0) return null;
+	if (!isAbsolute(cliPath)) throw new ApplicationError("INVALID_ARGUMENTS");
+	try {
+		return await readLocalCliBinding(cliPath, identity);
+	} catch (cause) {
+		throw new ApplicationError("ARTIFACT_INVALID_MANIFEST", void 0, { cause });
+	}
+}
+function invocation(args) {
+	if (process.platform === "win32") return `& ${args.map((value) => `'${value.replaceAll("'", "''")}'`).join(" ")}`;
+	return args.map((value) => `'${value.replaceAll("'", "'\\''")}'`).join(" ");
+}
+function inlineCode(value) {
+	const longest = Math.max(0, ...[...value.matchAll(/`+/gu)].map((match) => match[0].length));
+	const delimiter = "`".repeat(longest + 1);
+	return longest ? `${delimiter} ${value} ${delimiter}` : `${delimiter}${value}${delimiter}`;
+}
+function localCliInstructions(binding, directory, receiptSha256) {
+	const root = join(directory, "releases", binding.version);
+	const verifier = invocation([
+		binding.nodePath,
+		join(root, "scripts", "verify-cli.mjs"),
+		join(root, "cli-binding.json"),
+		receiptSha256
+	]);
+	const prefix = invocation([binding.nodePath, binding.cliPath]);
+	const shell = process.platform === "win32" ? "PowerShell" : "POSIX shell";
+	const fence = "`".repeat(Math.max(3, ...[...verifier.matchAll(/`+/gu)].map((match) => match[0].length + 1)));
+	return `Local candidate artifact SHA-256: \`${binding.artifactSha256}\`. Before any business call, run the read-only verifier in a ${shell} exactly as printed; preserve every absolute path:\n\n${fence}sh\n${verifier}\n${fence}\n\nRequire exit zero and stdout \`LOCAL_CLI_VERIFIED\`, then run ${inlineCode(`${prefix} --version`)} from the person's workspace and require stdout \`${binding.version}\`. Every subsequent CLI call and focused host uses the exact prefix ${inlineCode(prefix)} for this entire journey. Do not fetch this unpublished candidate from npm, substitute another executable or run \`skill.install\` yourself. A failed check stops setup before source access: tell the person this local candidate is missing or changed and needs a deliberate reinstall.`;
+}
+//#endregion
+//#region apps/cli/src/skill-install/release.ts
+const versionSchema = z.string().regex(/^\d+\.\d+\.\d+(?:-[\w.-]+)?(?:\+[\w.-]+)?$/);
+const digestSchema = z.string().regex(/^[a-f0-9]{64}$/);
+const manifestSchema = z.object({
+	schemaVersion: z.literal(1),
+	package: z.string(),
+	version: versionSchema,
+	entrySha256: digestSchema,
+	files: z.record(z.string(), digestSchema)
+}).strict();
+function collision(cause) {
+	throw new ApplicationError("ARTIFACT_DESTINATION_EXISTS", void 0, { cause });
+}
+function digest(value) {
+	return createHash("sha256").update(value).digest("hex");
+}
+async function exists(path) {
+	try {
+		return await lstat(path);
+	} catch (error) {
+		if (typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT") return null;
+		throw error;
+	}
+}
+async function filesAt(directory, prefix = "") {
+	const info = await lstat(directory);
+	if (!info.isDirectory() || info.isSymbolicLink()) collision();
+	const files = /* @__PURE__ */ new Map();
+	for (const item of (await readdir(directory, { withFileTypes: true })).sort((a, b) => a.name.localeCompare(b.name))) {
+		const path = join(directory, item.name);
+		const key = `${prefix}${item.name}`;
+		if (item.isDirectory()) for (const [name, value] of await filesAt(path, `${key}/`)) files.set(name, value);
+		else if (item.isFile()) files.set(key, await readFile(path));
+		else collision();
+	}
+	return files;
+}
+function fileDigests(files) {
+	return Object.fromEntries([...files].map(([name, value]) => [name, digest(value)]));
+}
+/** Bind examples to release assets without changing the person's workspace cwd. */
+function helperCommands(markdown, root, nodePath) {
+	const quote = (value) => `'${value.replaceAll("'", process.platform === "win32" ? "''" : "'\\''")}'`;
+	return markdown.replace(/(`+)([\s\S]*?)\1(?!`)/gu, (span, ticks, body) => {
+		const rendered = body.replace(/\bnode scripts\/([\w-]+\.mjs)\b/gu, (_match, name) => `${process.platform === "win32" ? "& " : ""}${quote(nodePath)} ${quote(join(root, "scripts", name))}`);
+		if (rendered === body) return span;
+		const delimiter = "`".repeat(Math.max(ticks.length, ...[...rendered.matchAll(/`+/gu)].map((match) => match[0].length + 1)));
+		return `${delimiter}${rendered}${delimiter}`;
+	});
+}
+/** Renders one entry; supporting releases deliberately contain no nested SKILL.md. */
+async function createRelease(identity, source, directory, local) {
+	if (!isAbsolute(directory)) throw new ApplicationError("INVALID_ARGUMENTS");
+	versionSchema.parse(identity.version);
+	if (!/^@[a-z0-9][a-z0-9._-]*\/[a-z0-9][a-z0-9._-]*$/.test(identity.name)) throw new ApplicationError("INVALID_ARGUMENTS");
+	const template = await readFile(join(source, "SKILL.md"), "utf8");
+	const marker = /<!-- sess-pilot-release -->[\s\S]*?<!-- \/sess-pilot-release -->/;
+	if (!marker.test(template)) throw new ApplicationError("ARTIFACT_INVALID_MANIFEST");
+	const prefix = `npx --yes ${identity.name}@${identity.version}`;
+	const receipt = local === void 0 ? null : `${JSON.stringify(local.binding)}\n`;
+	const instructions = local !== void 0 && receipt !== null ? localCliInstructions(local.binding, local.directory, digest(receipt)) : `Before any business call, run \`${prefix} --version\` from the person's workspace and require stdout \`${identity.version}\`; this CLI check is always the first command. Every subsequent CLI call and focused host uses the exact prefix \`${prefix}\` for this entire journey. Never run \`skill.install\` yourself: if the check fails, stop before source access and give the person \`${prefix} skill.install\` to reinstall this release.`;
+	const root = join(directory, "releases", identity.version);
+	const render = (value) => helperCommands(value, root, local?.binding.nodePath ?? "node");
+	const entry = render(template).replaceAll("](references/", `](releases/${identity.version}/references/`).replaceAll("](scripts/", `](releases/${identity.version}/scripts/`).replace(marker, () => `<!-- sess-pilot-managed:${identity.version} -->\n\nCLI release: \`${identity.name}@${identity.version}\`. ${instructions}`);
+	const files = await filesAt(join(source, "references"), "references/");
+	for (const [name, value] of files) if (name.endsWith(".md")) files.set(name, Buffer.from(render(value.toString("utf8")).replaceAll("](../SKILL.md", "](../../../SKILL.md")));
+	const scripts = join(source, "scripts");
+	if (await exists(scripts)) for (const [name, value] of await filesAt(scripts, "scripts/")) files.set(name, value);
+	if (receipt !== null) files.set("cli-binding.json", Buffer.from(receipt));
+	return {
+		identity,
+		entry,
+		files,
+		manifest: `${JSON.stringify({
+			schemaVersion: 1,
+			package: identity.name,
+			version: identity.version,
+			entrySha256: digest(entry),
+			files: fileDigests(files)
+		})}\n`
+	};
+}
+async function writeRelease(directory, release) {
+	const root = join(directory, "releases", release.identity.version);
+	await mkdir(root, { recursive: true });
+	for (const [name, value] of release.files) {
+		const path = join(root, name);
+		await mkdir(dirname(path), { recursive: true });
+		await writeFile(path, value, { flag: "wx" });
+	}
+	await writeFile(join(root, "manifest.json"), release.manifest, { flag: "wx" });
+	await writeFile(join(directory, "SKILL.md"), release.entry, { flag: "wx" });
+}
+/** Hashes all owned bytes before replacement and refuses foreign or edited files. */
+/** Earlier names of the package whose installed releases a new release may update (ADR 0209). */
+const formerPackageNames = ["@gitroll/tacitt"];
+async function verifyInstallation(directory, packageName) {
+	const info = await exists(directory);
+	if (info === null) return null;
+	if (!info.isDirectory() || info.isSymbolicLink()) collision();
+	if ((await readdir(directory)).sort().join("\n") !== "SKILL.md\nreleases") collision();
+	const entryPath = join(directory, "SKILL.md");
+	const entryInfo = await lstat(entryPath);
+	if (!entryInfo.isFile() || entryInfo.isSymbolicLink()) collision();
+	const entry = await readFile(entryPath, "utf8");
+	const match = /<!-- sess-pilot-managed:([^\s]+) -->/.exec(entry);
+	const currentVersion = versionSchema.safeParse(match?.[1]);
+	if (!currentVersion.success) collision();
+	const releaseRoot = join(directory, "releases");
+	const releaseInfo = await lstat(releaseRoot);
+	if (!releaseInfo.isDirectory() || releaseInfo.isSymbolicLink()) collision();
+	const releases = /* @__PURE__ */ new Map();
+	for (const version of await readdir(releaseRoot)) {
+		if (!versionSchema.safeParse(version).success) collision();
+		const files = await filesAt(join(releaseRoot, version));
+		const manifestBytes = files.get("manifest.json");
+		if (manifestBytes === void 0) collision();
+		files.delete("manifest.json");
+		let parsed;
+		try {
+			parsed = JSON.parse(manifestBytes.toString("utf8"));
+		} catch (error) {
+			collision(error);
+		}
+		const manifest = manifestSchema.safeParse(parsed);
+		if (!manifest.success) collision(manifest.error);
+		const value = manifest.data;
+		if (value.package !== packageName && !formerPackageNames.includes(value.package) || value.version !== version) collision();
+		const actual = fileDigests(files);
+		if (Object.keys(actual).length !== Object.keys(value.files).length || Object.entries(actual).some(([name, hash]) => value.files[name] !== hash)) collision();
+		if (version === currentVersion.data && value.entrySha256 !== digest(entry)) collision();
+		releases.set(version, manifestBytes.toString("utf8"));
+	}
+	if (!releases.has(currentVersion.data)) collision();
+	return {
+		entry,
+		releases
+	};
+}
+//#endregion
+//#region apps/cli/src/skill-install.ts
+const installSchema = z.object({
+	agent: z.enum([
+		"codex",
+		"claude",
+		"all"
+	]).default("all"),
+	scope: z.enum(["user", "project"]).default("user"),
+	directory: z.string().min(1).max(4096).optional(),
+	cliPath: z.string().min(1).max(4096).optional(),
+	configureAgents: z.boolean().optional()
+}).strict().refine((input) => input.directory === void 0 || input.scope === "project");
+/** Installs native entries without creating or opening any Application state. */
+async function installSkill(value = {}) {
+	const input = installSchema.parse(value);
+	const identity = { ...packageIdentity };
+	const source = fileURLToPath(new URL("../skills/tacitt/", import.meta.url));
+	const binding = await localCliBinding(input.cliPath, identity);
+	const agents = input.agent === "all" ? ["codex", "claude"] : [input.agent];
+	const root = input.scope === "user" ? homedir() : resolve(input.directory ?? process.cwd());
+	const installs = [];
+	for (const agent of agents) {
+		const directory = join(root, agent === "codex" ? ".agents" : ".claude", "skills", "tacitt");
+		const release = await createRelease(identity, source, directory, binding === null ? void 0 : {
+			binding,
+			directory
+		});
+		installs.push({
+			agent,
+			directory,
+			status: await installRelease(directory, release)
+		});
+	}
+	return {
+		skill: "tacitt",
+		package: identity.name,
+		version: identity.version,
+		...binding === null ? {} : { localCli: binding },
+		installs
+	};
+}
+async function installRelease(directory, release) {
+	const parent = dirname(directory);
+	await mkdir(parent, { recursive: true });
+	const coordinationRoot = join(dirname(parent), ".sess-pilot-installer");
+	try {
+		await makePrivateDirectory(coordinationRoot);
+	} catch (error) {
+		if (!(typeof error === "object" && error !== null && "code" in error && error.code === "EEXIST")) throw error;
+	}
+	const claim = await createExecutionPort(coordinationRoot).tryAcquire("workflow");
+	if (claim === null) throw new ApplicationError("COORDINATION_BUSY");
+	let staging;
+	let primary;
+	const failures = [];
+	let status = "installed";
+	try {
+		const previous = await verifyInstallation(directory, release.identity.name);
+		const existingRelease = previous?.releases.get(release.identity.version);
+		if (existingRelease !== void 0 && existingRelease !== release.manifest) throw new ApplicationError("ARTIFACT_DESTINATION_EXISTS");
+		if (previous?.entry === release.entry) status = "unchanged";
+		else {
+			staging = await mkdtemp(join(coordinationRoot, ".sess-pilot-install-"));
+			await writeRelease(staging, release);
+			if (previous === null) {
+				await rename(staging, directory);
+				staging = void 0;
+			} else {
+				status = "updated";
+				if (existingRelease === void 0) await rename(join(staging, "releases", release.identity.version), join(directory, "releases", release.identity.version));
+				if ((await verifyInstallation(directory, release.identity.name))?.entry !== previous.entry) throw new ApplicationError("ARTIFACT_DESTINATION_EXISTS");
+				await rename(join(staging, "SKILL.md"), join(directory, "SKILL.md"));
+			}
+			if (await readFile(join(directory, "SKILL.md"), "utf8") !== release.entry) throw new ApplicationError("ARTIFACT_IO_FAILED");
+		}
+	} catch (error) {
+		primary = error;
+	} finally {
+		const cleanup = await Promise.allSettled([...staging === void 0 ? [] : [rm(staging, {
+			recursive: true,
+			force: true
+		})], claim.release()]);
+		failures.push(...cleanup.flatMap((result) => result.status === "rejected" ? [result.reason] : []));
+		if (failures.length > 0) try {
+			process.stderr.write(`${JSON.stringify({
+				event: "skill.install_cleanup_failed",
+				failures: failures.length
+			})}\n`);
+		} catch (error) {
+			failures.push(error);
+		}
+	}
+	if (failures.length > 0) throw new AggregateError(primary === void 0 ? failures : [primary, ...failures], primary === void 0 ? "ARTIFACT_IO_FAILED" : safeCode(primary), { cause: primary ?? failures[0] });
+	if (primary !== void 0) throw primary;
+	return status;
+}
+//#endregion
+//#region apps/cli/src/skill-install/config-file.ts
+const maxBytes = 1048576;
+const absent = (error) => error instanceof Error && "code" in error && error.code === "ENOENT";
+/** Refuse symlink destinations and bound configuration reads, including growth while reading. */
+async function readConfiguration(path) {
+	try {
+		const directory = await lstat(dirname(path));
+		if (!directory.isDirectory() || directory.isSymbolicLink()) throw new Error("AGENT_CONFIG_UNSAFE");
+		const entry = await lstat(path);
+		if (!entry.isFile() || entry.isSymbolicLink() || entry.nlink !== 1) throw new Error("AGENT_CONFIG_UNSAFE");
+		const file = await open(path, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0));
+		try {
+			const stat = await file.stat();
+			if (stat.ino !== entry.ino || stat.dev !== entry.dev || stat.size > maxBytes) throw new Error("AGENT_CONFIG_UNSAFE");
+			const chunks = [];
+			let bytes = 0;
+			for await (const chunk of file.createReadStream({ autoClose: false })) {
+				const part = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+				bytes += part.length;
+				if (bytes > maxBytes) throw new Error("AGENT_CONFIG_UNSAFE");
+				chunks.push(part);
+			}
+			return new TextDecoder("utf-8", { fatal: true }).decode(Buffer.concat(chunks));
+		} finally {
+			await file.close();
+		}
+	} catch (error) {
+		if (absent(error)) return null;
+		throw error;
+	}
+}
+/** Stage privately, refuse observed concurrent edits, then publish and read back exact bytes. */
+async function saveConfiguration(path, previous, next) {
+	if (Buffer.byteLength(next, "utf8") > maxBytes) throw new Error("AGENT_CONFIG_UNSAFE");
+	await mkdir(dirname(path), {
+		recursive: true,
+		mode: 448
+	});
+	if (await readConfiguration(path) !== previous) throw new Error("AGENT_CONFIG_CHANGED");
+	const coordination = join(dirname(path), ".sess-pilot-installer");
+	try {
+		await makePrivateDirectory(coordination);
+	} catch (error) {
+		if (!(error instanceof Error && "code" in error && error.code === "EEXIST")) throw error;
+	}
+	const claim = await createExecutionPort(coordination).tryAcquire("workflow");
+	if (claim === null) throw new Error("AGENT_CONFIG_BUSY");
+	const temporary = join(dirname(path), `.sess-pilot-config-${randomUUID()}`);
+	let primary;
+	const failures = [];
+	try {
+		const file = await openPrivateFile(temporary, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL);
+		try {
+			await file.writeFile(next);
+			await file.sync();
+		} finally {
+			await file.close();
+		}
+		if (await readConfiguration(path) !== previous) throw new Error("AGENT_CONFIG_CHANGED");
+		await rename(temporary, path);
+		if (await readConfiguration(path) !== next) throw new Error("AGENT_CONFIG_READBACK_FAILED");
+	} catch (cause) {
+		primary = cause;
+	} finally {
+		const cleanup = await Promise.allSettled([rm(temporary, { force: true }), claim.release()]);
+		failures.push(...cleanup.flatMap((result) => result.status === "rejected" ? [result.reason] : []));
+	}
+	if (failures.length) throw new AggregateError(primary === void 0 ? failures : [primary, ...failures], "AGENT_CONFIG_FAILED", { cause: primary ?? failures[0] });
+	if (primary !== void 0) throw primary;
+}
+const object = z.record(z.string(), z.unknown());
+/** Edit only the count; preserve unrelated values and the existing TOML representation. */
+function configureText(agent, source) {
+	try {
+		const data = object.parse(source.trim() ? agent === "codex" ? parse(source) : JSON.parse(source) : {});
+		const key = agent === "codex" ? "agents" : "env";
+		const section = data[key] === void 0 ? {} : object.parse(data[key]);
+		const field = agent === "claude" ? "CLAUDE_CODE_MAX_CONCURRENT_SUBAGENTS" : Object.hasOwn(section, "max_concurrent_threads_per_session") || !Object.hasOwn(section, "max_threads") ? "max_concurrent_threads_per_session" : "max_threads";
+		const current = section[field];
+		const count = current === void 0 ? void 0 : agent === "claude" ? z.string().regex(/^\d+$/).transform(Number).pipe(z.number().int().positive().safe()).parse(current) : z.number().int().positive().safe().parse(current);
+		if (count !== void 0 && count >= 16) return {
+			text: source,
+			count
+		};
+		const target = agent === "claude" ? String(16) : 16;
+		const updated = {
+			...data,
+			[key]: {
+				...section,
+				[field]: target
+			}
+		};
+		const text = agent === "codex" ? patch(source, updated) : applyEdits(source.trim() ? source : "{}\n", modify(source.trim() ? source : "{}\n", ["env", field], target, { formattingOptions: {
+			insertSpaces: true,
+			tabSize: 2
+		} }));
+		const check = object.parse(agent === "codex" ? parse(text) : JSON.parse(text));
+		if (object.parse(check[key])[field] !== target) throw new Error("CONFIG_READBACK_FAILED");
+		return {
+			text,
+			count: 16
+		};
+	} catch (cause) {
+		throw new Error("AGENT_CONFIG_INVALID", { cause });
+	}
+}
+//#endregion
+//#region apps/cli/src/skill-install/consent.ts
+/** A closed terminal or cancellation is a refusal; npm --yes is never client-setting consent. */
+async function askAgentConfiguration(clients, scope) {
+	const names = clients.map((agent) => agent === "codex" ? "Codex" : "Claude Code").join(" and ");
+	const terminal = createInterface({
+		input: process.stdin,
+		output: process.stderr,
+		terminal: true
+	});
+	try {
+		process.stderr.write(`SessPilot uses up to 16 analysis subagents for faster review.\nRaise the concurrent subagent limit to 16 for ${names}? Higher limits can increase concurrent usage.
+` + (scope === "user" ? "This changes your client settings across projects.\n" : "This changes client settings for this project.\n") + "Save your work and fully restart the affected App or CLI afterward. We will not close it for you.\nAllow this change? [y/N] ");
+		return await new Promise((resolve) => {
+			terminal.once("line", (line) => resolve(/^y(?:es)?$/i.test(line.trim())));
+			terminal.once("close", () => resolve(false));
+			terminal.once("SIGINT", () => resolve(false));
+		});
+	} finally {
+		terminal.close();
+	}
+}
+//#endregion
+//#region apps/cli/src/skill-install/agent-config.ts
+const settings = z.object({
+	scope: z.enum(["user", "project"]).default("user"),
+	directory: z.string().optional(),
+	configureAgents: z.boolean().optional()
+});
+/** Installer-only configuration; no client is launched or treated as hot-reloaded. */
+async function configureInstalledAgents(value, installation, options) {
+	const input = settings.parse(value);
+	const clients = installation.installs.map(({ agent }) => z.enum(["codex", "claude"]).parse(agent));
+	const interactive = options.input === void 0 && Boolean(process.stdin.isTTY && process.stderr.isTTY);
+	if (input.configureAgents === false || input.configureAgents !== true && !interactive) return clients.map((agent) => ({
+		agent,
+		status: input.configureAgents === false ? "declined" : "skipped"
+	}));
+	const results = [];
+	const plans = [];
+	for (const agent of clients) {
+		const root = input.scope === "project" ? join(resolve(input.directory ?? process.cwd()), agent === "codex" ? ".codex" : ".claude") : agent === "codex" ? options.codexHome : options.claudeHome;
+		const path = join(root, agent === "codex" ? "config.toml" : input.scope === "project" ? "settings.local.json" : "settings.json");
+		try {
+			const previous = await readConfiguration(path);
+			const edit = configureText(agent, previous ?? "");
+			if (edit.text === previous) results.push({
+				agent,
+				status: "unchanged",
+				count: edit.count
+			});
+			else plans.push({
+				agent,
+				path,
+				previous,
+				edit
+			});
+		} catch (cause) {
+			results.push(configurationFailure(agent, cause));
+		}
+	}
+	if (plans.length === 0) return results;
+	const allowed = input.configureAgents === true || await askAgentConfiguration(plans.map(({ agent }) => agent), input.scope);
+	for (const plan of plans) {
+		if (!allowed) {
+			results.push({
+				agent: plan.agent,
+				status: "declined"
+			});
+			continue;
+		}
+		try {
+			await saveConfiguration(plan.path, plan.previous, plan.edit.text);
+			results.push({
+				agent: plan.agent,
+				status: "updated",
+				count: plan.edit.count
+			});
+		} catch (cause) {
+			results.push(configurationFailure(plan.agent, cause));
+		}
+	}
+	return results;
+}
+function configurationFailure(agent, cause) {
+	const code = cause instanceof Error && [
+		"AGENT_CONFIG_INVALID",
+		"AGENT_CONFIG_UNSAFE",
+		"AGENT_CONFIG_CHANGED",
+		"AGENT_CONFIG_BUSY",
+		"AGENT_CONFIG_READBACK_FAILED"
+	].includes(cause.message) ? cause.message : "AGENT_CONFIG_FAILED";
+	process.stderr.write(`${JSON.stringify({
+		event: "skill.agent_config_failed",
+		agent,
+		code
+	})}\n`);
+	return {
+		agent,
+		status: "failed",
+		code
+	};
+}
+//#endregion
+//#region apps/cli/src/skill-install/notice.ts
+/** Human shorthand guidance stays outside the machine-readable stdout envelope. */
+function writeInstallNotice(result) {
+	const commands = result.installs.map(({ agent }) => agent === "codex" ? "  Codex: $tacitt" : "  Claude Code: /tacitt");
+	const message = [
+		"SessPilot Skill is ready.",
+		...result.agentConfiguration.flatMap(({ agent, status, count }) => {
+			const name = agent === "codex" ? "Codex" : "Claude Code";
+			if (status === "updated" || status === "unchanged") return [`${name}: concurrent subagent setting ${status === "updated" ? "saved" : "already set"} at ${count}.`, ...agent === "claude" ? ["Claude Code must be version 2.1.217 or newer for this setting. Update older versions first."] : []];
+			if (status === "failed") return [`${name}: settings could not be updated. Skill installed; retry configuration after resolving the reported error.`];
+			return [`${name}: client settings were not changed. Review uses the available slots.`];
+		}),
+		...result.agentConfiguration.some(({ status }) => status === "updated" || status === "unchanged") ? ["Save your work, fully quit and reopen the affected App, or exit and relaunch its CLI.", "Already-open chats may retain their previous limit. No App or CLI was restarted."] : [],
+		...result.agentConfiguration.some(({ status }) => status === "skipped") ? ["To allow configuration in a noninteractive install, rerun skill.install with --configure-agents."] : [],
+		"Open a new conversation in your installed client and enter:",
+		...commands,
+		"Your agent will guide permissions, scanning, AI privacy review, preview and Send.",
+		""
+	].join("\n");
+	return new Promise((resolve, reject) => {
+		process.stderr.write(message, (error) => error ? reject(error) : resolve());
+	});
+}
+//#endregion
+//#region apps/cli/src/serve-detach.ts
+const readySchema = z.object({
+	event: z.literal("ready"),
+	result: z.object({
+		url: z.string(),
+		journeyId: z.string()
+	})
+});
+/** The same CLI arguments without `--detach` and with the journey read from `input`. */
+function hostArguments(args, input) {
+	const kept = [];
+	for (let index = 0; index < args.length; index += 1) {
+		const arg = args[index];
+		if (arg === void 0 || arg === "--detach" || arg.startsWith("--input=")) continue;
+		if (arg === "--input") {
+			index += 1;
+			continue;
+		}
+		kept.push(arg);
+	}
+	return [
+		...kept,
+		"--input",
+		input
+	];
+}
+/**
+* Starts `journey.serve` in its own process group, outside the agent tool that ran this command,
+* so an agent host's limit on background tasks does not stop the panel mid-Send (BL-210). The
+* host's output goes to an owner-only log; this command prints its readiness with the pid.
+*/
+async function serveDetached(args, stateDir, journeyId) {
+	const directory = join(stateDir, "serve");
+	await mkdir(directory, {
+		recursive: true,
+		mode: 448
+	});
+	const id = randomUUID();
+	const input = join(directory, `${id}.json`);
+	const log = join(directory, `${id}.log`);
+	await writeFile(input, JSON.stringify({ journeyId }), { mode: 384 });
+	const output = await open(log, "w", 384);
+	const entry = process.argv[1];
+	if (!entry) throw new Error("INVALID_ARGUMENTS");
+	const child = spawn(process.execPath, [
+		...process.execArgv,
+		entry,
+		...hostArguments(args, input)
+	], {
+		detached: true,
+		stdio: [
+			"ignore",
+			output.fd,
+			output.fd
+		]
+	});
+	let exited = null;
+	child.once("exit", (code) => exited = code ?? 1);
+	child.unref();
+	await output.close();
+	for (let waited = 0; waited < 6e4; waited += 100) {
+		const ready = (await readFile(log, "utf8")).split("\n").flatMap((line) => {
+			try {
+				const value = readySchema.safeParse(JSON.parse(line));
+				return value.success ? [value.data.result] : [];
+			} catch {
+				return [];
+			}
+		})[0];
+		if (ready) {
+			process.stdout.write(`${JSON.stringify({
+				ok: true,
+				event: "ready",
+				result: {
+					...ready,
+					pid: child.pid,
+					log
+				}
+			})}\n`);
+			return;
+		}
+		if (exited !== null) break;
+		await setTimeout$1(100);
+	}
+	if (exited === null) child.kill();
+	process.stderr.write(`The panel host did not start. Its output is in ${log}.\n`);
+	process.exitCode = 1;
+}
+//#endregion
+//#region apps/cli/src/business-input.ts
+const defaultBusinessInputBytes = 1048576;
+const reviewCommands = /* @__PURE__ */ new Set([
+	"review.terms",
+	"journey.classificationSubmit",
+	"journey.classificationProgress",
+	"journey.cardsSubmit",
+	"journey.resolve"
+]);
+/** Bound bytes before parsing; only evidence- and pack-bearing commands need the larger envelope. */
+async function readBusinessInput(options) {
+	if (!options.input) return null;
+	const limit = reviewCommands.has(options.command ?? "") ? reviewTransportBytes : defaultBusinessInputBytes;
+	const chunks = [];
+	let bytes = 0;
+	const stream = options.input === "-" ? process.stdin : createReadStream(options.input);
+	for await (const chunk of stream) {
+		const part = Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk));
+		bytes += part.length;
+		if (bytes > limit) throw new ApplicationError("INVALID_ARGUMENTS");
+		chunks.push(part);
+	}
+	try {
+		return JSON.parse(Buffer.concat(chunks).toString("utf8"));
+	} catch {
+		throw new ApplicationError("INVALID_ARGUMENTS");
+	}
+}
+//#endregion
+//#region apps/cli/src/output.ts
+const writeJson = (value) => new Promise((resolve, reject) => {
+	process.stdout.write(`${JSON.stringify(value)}\n`, (error) => error ? reject(error) : resolve());
+});
+//#endregion
+//#region apps/cli/src/review-stream.ts
+/** Procedures the review helper sends; each runs exactly as its own `--input` command would. */
+const streamProcedures = /* @__PURE__ */ new Set([
+	"journey.get",
+	"journey.prepare",
+	"journey.catalog",
+	"journey.classificationSessions",
+	"journey.classificationProgress",
+	"journey.classificationRead",
+	"journey.classificationSubmit",
+	"journey.cardsRead",
+	"journey.cardsSubmit",
+	"journey.resolve",
+	"journey.read",
+	"review.guidance",
+	"review.status",
+	"review.terms"
+]);
+const request = z.object({
+	id: z.number().int().nonnegative(),
+	procedure: z.string(),
+	input: z.unknown()
+}).strict();
+/**
+* One runtime for many review calls: each stdin line `{id, procedure, input}` gets one stdout
+* line `{id, ok, result | error}`, in order. Saves a process start per call; ends at stdin EOF.
+*/
+async function reviewStream(options) {
+	let runtime;
+	try {
+		runtime = await createRuntime(options);
+	} catch (error) {
+		await writeJson({
+			event: "review.stream.startup-failed",
+			ok: false,
+			error: {
+				code: safeCode(error),
+				field: safeField(error)
+			}
+		});
+		process.exitCode = 1;
+		return;
+	}
+	const abort = new AbortController();
+	const lines = createInterface({
+		input: process.stdin,
+		crlfDelay: Infinity
+	});
+	const onSignal = () => {
+		abort.abort();
+		lines.close();
+	};
+	process.once("SIGINT", onSignal);
+	process.once("SIGTERM", onSignal);
+	try {
+		for await (const line of lines) {
+			if (!line.trim()) continue;
+			let id = null;
+			try {
+				if (Buffer.byteLength(line) > 33554432) throw new ApplicationError("INVALID_ARGUMENTS");
+				const call = request.parse(JSON.parse(line));
+				id = call.id;
+				if (!streamProcedures.has(call.procedure)) throw new ApplicationError("INVALID_ARGUMENTS");
+				const result = await invoke(runtime, call.procedure, call.input ?? null, abort.signal);
+				await writeJson({
+					id,
+					ok: true,
+					result
+				});
+			} catch (error) {
+				runtime.diagnostics.onFailure("command", error);
+				const invalid = error instanceof z.ZodError || error instanceof SyntaxError;
+				await writeJson({
+					id,
+					ok: false,
+					error: {
+						code: invalid ? "INVALID_ARGUMENTS" : safeCode(error),
+						field: safeField(error)
+					}
+				});
+			}
+		}
+	} finally {
+		process.removeListener("SIGINT", onSignal);
+		process.removeListener("SIGTERM", onSignal);
+		await runtime.close();
+	}
+}
+//#endregion
+//#region apps/cli/src/operation/client.ts
+async function executeLong(options, args, value) {
+	const source = import.meta.url.endsWith(".ts");
+	const entry = fileURLToPath(new URL(source ? "./executor.ts" : "./operation-executor.mjs", import.meta.url));
+	const child = spawn(process.execPath, [...source && process.platform === "win32" ? ["--liftoff-only"] : [], entry], {
+		cwd: process.cwd(),
+		detached: true,
+		windowsHide: true,
+		stdio: [
+			"ignore",
+			"ignore",
+			"ignore",
+			"ipc"
+		]
+	});
+	let operationId;
+	let detached = false;
+	let terminal = false;
+	let timer;
+	const { promise: done, resolve: finish, reject } = Promise.withResolvers();
+	const terminate = () => {
+		if (!detached && !terminal) child.kill("SIGTERM");
+	};
+	process.once("SIGINT", terminate);
+	process.once("SIGTERM", terminate);
+	const detach = () => {
+		if (!child.connected || !operationId) return;
+		child.send({ detach: true }, (error) => {
+			if (error) reject(error);
+		});
+	};
+	const receive = async (event) => {
+		if (terminal || detached) return;
+		if (event.event === "diagnostic") {
+			process.stderr.write(`${JSON.stringify(event)}\n`);
+			return;
+		}
+		if (event.event === "progress") {
+			await writeJson(event);
+			return;
+		}
+		if (event.event === "started") {
+			operationId = event.operationId;
+			await writeJson(event);
+			if (options.async) detach();
+			else timer = globalThis.setTimeout(detach, options.timeoutMs);
+		} else if (event.event === "detached") {
+			detached = true;
+			child.unref();
+			await writeJson({
+				event: options.async ? "accepted" : "timeout",
+				operationId: event.operationId,
+				detached: true
+			});
+			if (!options.async) process.exitCode = 3;
+			finish();
+		} else {
+			terminal = true;
+			await writeJson(event);
+			if (event.event === "error") process.exitCode = event.code === "INVALID_ARGUMENTS" ? 2 : 1;
+			else if (typeof event.result === "object" && event.result !== null && "status" in event.result && event.result.status !== "completed") process.exitCode = 1;
+			finish();
+		}
+	};
+	let receiving = Promise.resolve();
+	child.on("message", (message) => {
+		receiving = receiving.then(async () => {
+			const event = executorEventSchema.parse(message);
+			await receive(event);
+		}).catch(reject);
+	});
+	child.once("error", reject);
+	child.once("exit", () => {
+		receiving.then(() => {
+			if (!terminal && !detached) reject(new ApplicationError("OPERATION_FAILED"));
+		});
+	});
+	child.send({
+		command: options.command,
+		input: value,
+		args
+	}, (error) => {
+		if (error) reject(error);
+	});
+	try {
+		await done;
+	} finally {
+		if (timer) clearTimeout(timer);
+		process.removeListener("SIGINT", terminate);
+		process.removeListener("SIGTERM", terminate);
+		if (!detached && child.connected) child.disconnect();
+		if (!detached && !terminal) child.kill("SIGTERM");
+	}
+}
+//#endregion
+//#region apps/cli/src/business.ts
+async function business(options, args) {
+	try {
+		if (options.command === "review.stream") {
+			await reviewStream(options);
+			return;
+		}
+		const value = await readBusinessInput(options);
+		if (options.command === "journey.serve") {
+			const { journeyId } = z.object({ journeyId: z.string().uuid() }).strict().parse(value);
+			if (options.detach) await serveDetached(args, options.stateDir, journeyId);
+			else await serve(options, journeyId);
+			return;
+		}
+		if (options.command === "skill.install") {
+			const installation = options.input === void 0 ? {
+				agent: options.agent ?? "all",
+				scope: options.scope ?? "user",
+				...options["cli-path"] === void 0 ? {} : { cliPath: options["cli-path"] },
+				...options["configure-agents"] === true ? { configureAgents: true } : {},
+				...options["skip-agent-config"] === true ? { configureAgents: false } : {}
+			} : value;
+			const result = await installSkill(installation);
+			const agentConfiguration = await configureInstalledAgents(installation, result, options);
+			const complete = {
+				...result,
+				agentConfiguration
+			};
+			const ok = !agentConfiguration.some(({ status }) => status === "failed");
+			if (options.input === void 0) await writeInstallNotice(complete);
+			await writeJson({
+				ok,
+				result: complete,
+				...!ok ? { error: { code: "AGENT_CONFIG_FAILED" } } : {}
+			});
+			if (!ok) process.exitCode = 1;
+			return;
+		}
+		if (options.command && longCommands.has(options.command)) {
+			await executeLong(options, args, value);
+			return;
+		}
+		const runtime = await createRuntime(options);
+		const abort = new AbortController();
+		const onSignal = () => abort.abort();
+		process.once("SIGINT", onSignal);
+		process.once("SIGTERM", onSignal);
+		let response;
+		let failed = false;
+		let primary;
+		try {
+			traceStartup("command-start");
+			if (options.command === "operation.get") response = {
+				ok: true,
+				result: await readOperation(runtime, options.operationId ?? "")
+			};
+			else if (options.command === "operation.cancel") response = {
+				ok: true,
+				result: await cancelOperation(runtime, options.operationId ?? "")
+			};
+			else if (options.command === "operation.wait") {
+				const result = await waitOperation(runtime, options.operationId ?? "", options.timeoutMs, abort.signal);
+				response = {
+					ok: !result.timedOut && result.operation.status === "completed",
+					...result
+				};
+				process.exitCode = result.timedOut ? 3 : result.operation.status === "completed" ? 0 : 1;
+			} else if (options.command === "workflow.events") {
+				const deadline = performance.now() + options.timeoutMs;
+				let previous = "";
+				while (performance.now() < deadline && !abort.signal.aborted) {
+					const current = await runtime.application.getCurrent();
+					const serialized = JSON.stringify(current);
+					if (serialized !== previous) {
+						await writeJson({
+							event: "state",
+							result: current
+						});
+						previous = serialized;
+					}
+					await setTimeout$1(Math.min(200, Math.max(1, deadline - performance.now())), void 0, { signal: abort.signal });
+				}
+			} else response = {
+				ok: true,
+				result: await invoke(runtime, options.command ?? "", value, abort.signal)
+			};
+		} catch (error) {
+			failed = true;
+			primary = error;
+			runtime.diagnostics.onFailure("command", error);
+		} finally {
+			traceStartup("command-end");
+			process.removeListener("SIGINT", onSignal);
+			process.removeListener("SIGTERM", onSignal);
+			try {
+				await runtime.close();
+			} catch (error) {
+				primary = failed ? new AggregateError([primary, error], safeCode(primary), { cause: primary }) : error;
+				failed = true;
+			}
+		}
+		if (failed) throw primary;
+		if (response !== void 0) await writeJson(response);
+	} catch (error) {
+		const code = error instanceof z.ZodError ? "INVALID_ARGUMENTS" : safeCode(error);
+		const detail = startupFailure(error instanceof z.ZodError ? new ApplicationError("INVALID_ARGUMENTS", void 0, { cause: error }) : error).trim();
+		process.stderr.write(`${JSON.stringify({
+			event: "cli.failed",
+			code,
+			detail
+		})}\n`);
+		await writeJson({
+			ok: false,
+			error: {
+				code,
+				field: safeField(error),
+				detail
+			}
+		});
+		process.exitCode = code === "INVALID_ARGUMENTS" ? 2 : 1;
+	}
+}
+//#endregion
+//#region apps/cli/src/cli.ts
+const stateDumpSchema = z.object({ state: z.unknown() });
+async function main() {
+	traceStartup("entry-ready");
+	process.umask(63);
+	const options = parseOptions(process.argv.slice(2));
+	if (options.help) {
+		process.stdout.write(helpText());
+		return;
+	}
+	if (options.version) {
+		process.stdout.write(`${packageIdentity.version}\n`);
+		return;
+	}
+	if (options.status) {
+		const dump = stateDumpSchema.parse(await readStateDump(options.stateDir));
+		const state = stateSchema.parse(dump.state);
+		const run = state.current?.operation ? state.current : state.baseline;
+		for (const activity of await createRenderActivity(options.stateDir).list()) process.stdout.write(`Journey ${activity.journeyId} is packaging ${activity.workIds.length} Works since ${activity.startedAt}\n`);
+		if (!run?.operation) {
+			process.stdout.write("No packaging operation is available.\n");
+			return;
+		}
+		const outcomes = readWorkspaceOutcomes(run);
+		process.stdout.write(`Packaging operation ${run.operation.id} (${run.phase})\n`);
+		if (outcomes.length === 0) {
+			process.stdout.write("No partial workspace outcomes are saved.\n");
+			return;
+		}
+		for (const outcome of outcomes) {
+			const title = resolveFailureLocation(run.operation.approval.inventory, {
+				workspaceId: outcome.workspaceId,
+				...outcome.status === "failed" && outcome.sessionId ? { sessionId: outcome.sessionId } : {},
+				...outcome.status === "failed" && outcome.sourcePartId ? { sourcePartId: outcome.sourcePartId } : {}
+			})?.workspace.name ?? "Workspace";
+			const status = outcome.status === "failed" ? `${outcome.status} · ${outcome.code} · ${outcome.stage}` : outcome.status;
+			const details = outcome.status === "failed" ? [outcome.sessionId && `session ${outcome.sessionId}`, outcome.sourcePartId && `source ${outcome.sourcePartId}`].filter(Boolean).join(" · ") : "";
+			process.stdout.write(`${title} [${outcome.workspaceId}]: ${status}${details ? ` · ${details}` : ""}\n`);
+		}
+		return;
+	}
+	if (options.stateDump) {
+		const timing = process.env["CI"] === "true" && process.env["SESS_PILOT_TEST_STATE_DUMP_PHASES"] === "1";
+		let phaseStarted = performance.now();
+		const reportPhase = (phase) => {
+			if (timing) process.stderr.write(`STATE_DUMP_PHASE_MS ${phase} ${Math.round(performance.now() - phaseStarted)}\n`);
+			phaseStarted = performance.now();
+		};
+		const dump = JSON.stringify(await readStateDump(options.stateDir), null, 2) + "\n";
+		reportPhase("read_serialize");
+		process.stderr.write("Sensitive state metadata includes local paths and session references.\n");
+		if (options.output) {
+			const handle = await openPrivateFile(options.output, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL);
+			reportPhase("private_open");
+			try {
+				await handle.writeFile(dump);
+				await handle.sync();
+			} finally {
+				await handle.close();
+			}
+			reportPhase("write_sync_close");
+		} else process.stdout.write(dump);
+		return;
+	}
+	if (options.command) await business(options, process.argv.slice(2));
+	else await serve(options);
+}
+main().catch(async (error) => {
+	if (process.argv.slice(2).find((argument) => businessCommands.some((name) => name === argument))) {
+		const code = safeCode(error);
+		await writeJson({
+			ok: false,
+			error: {
+				code,
+				field: safeField(error),
+				detail: startupFailure(error).trim()
+			}
+		});
+		process.stderr.write(`${code}: command failed.\n`);
+		process.exitCode = code === "INVALID_ARGUMENTS" ? 2 : 1;
+	} else {
+		process.stderr.write(startupFailure(error));
+		process.exitCode = 1;
+	}
+});
+//#endregion
+export {};