@gajae-code/coding-agent 0.17.1 → 0.17.4

package/scripts/embed-mupdf.ts

@@ -0,0 +1,52 @@
+#!/usr/bin/env bun
+
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import * as url from "node:url";
+
+const outputPath = url.fileURLToPath(new URL("../src/utils/mupdf-embedded.ts", import.meta.url));
+const sourceMapping = `// AUTOGENERATED FILE -- DO NOT EDIT DIRECTLY
+// See scripts/embed-mupdf.ts. Source installs resolve the package lazily.
+export const embeddedMuPdfWasm: string | undefined = undefined;
+export const embeddedMuPdfModule: string | undefined = undefined;
+`;
+
+export async function resetMuPdfAsset(): Promise<void> {
+	await Bun.write(outputPath, sourceMapping);
+}
+
+export async function generateMuPdfAsset(options: { wasmPath?: string } = {}): Promise<void> {
+	const temporaryPath = `${outputPath}.tmp`;
+	try {
+		const markitModule = url.fileURLToPath(new URL("../vendor/markit-ai/dist/index.js", import.meta.url));
+		const modulePath = Bun.resolveSync("mupdf", path.dirname(markitModule));
+		const resolvedWasmPath = options.wasmPath ?? path.join(path.dirname(modulePath), "mupdf-wasm.wasm");
+		await fs.access(resolvedWasmPath);
+		await Bun.write(
+			temporaryPath,
+			`// AUTOGENERATED FILE -- DO NOT EDIT DIRECTLY
+// See scripts/embed-mupdf.ts. Reset after compiling.
+import wasmAsset from ${JSON.stringify(resolvedWasmPath)} with { type: "file" };
+
+export const embeddedMuPdfWasm: string | undefined = wasmAsset;
+export const embeddedMuPdfModule: string | undefined = ${JSON.stringify(modulePath)};
+`,
+		);
+		await fs.rename(temporaryPath, outputPath);
+	} catch (cause) {
+		await resetMuPdfAsset();
+		throw new Error(
+			"Unable to embed MuPDF WASM; check the source-built artifact or installed coding-agent dependency.",
+			{
+				cause,
+			},
+		);
+	} finally {
+		await fs.rm(temporaryPath, { force: true });
+	}
+}
+
+if (import.meta.main) {
+	if (process.argv.includes("--reset")) await resetMuPdfAsset();
+	else await generateMuPdfAsset();
+}

package/scripts/generate-sdk-operation-inventory.ts

@@ -19,8 +19,12 @@ const LOCKED_EXCLUSIONS: Readonly<Record<string, string>> = {
 		"internal terminal-abort bus seam, threaded via terminalAbortSeams; not a user-facing SDK control seam",
 	"agent_session:abortPromptAndWaitWithTerminal":
 		"internal terminal-abort fencing seam, threaded via terminalAbortSeams; not a user-facing SDK control seam",
+	"agent_session:pendingToolExecutions":
+		"internal read-only run-resource-ledger view, threaded via terminalAbortSeams so the prompt deadline can find a tool-call boundary; not a user-facing SDK control seam",
 	"slash_command:routing":
 		"visual/local-only autorouting settings toggle and smart-routing panel entry, not a user-facing SDK control seam",
+	"slash_command:mcp":
+		"interactive exact-config MCP status and session control command; terminal-only handleTui surface is not dispatched through ACP or the public SDK",
 	"slash_command:settings": "visual/local-only command, not a user-facing SDK control seam",
 	"slash_command:theme": "visual/local-only command, not a user-facing SDK control seam",
 	"slash_command:language":
@@ -162,6 +166,10 @@ const LOCKED_EXCLUSIONS: Readonly<Record<string, string>> = {
 	"agent_session:refreshSshTool": "internal accessor/plumbing, not a user-facing control seam",
 	"agent_session:refreshBaseSystemPrompt": "internal accessor/plumbing, not a user-facing control seam",
 	"agent_session:refreshMCPTools": "internal accessor/plumbing, not a user-facing control seam",
+	"agent_session:getExactMcpStatusSnapshot":
+		"internal exact-config MCP status accessor used only by the terminal-only /mcp command; its capability is granted only to root interactive --mcp-config sessions, not a public SDK query",
+	"agent_session:controlExactMcpServer":
+		"internal session-local exact-config MCP suspend/resume/reconnect mutation used only by the terminal-only /mcp command; runtime suppression is not persistent user authority or a public SDK control",
 	"agent_session:refreshGjcSubskillTools": "internal accessor/plumbing, not a user-facing control seam",
 	"agent_session:buildDisplaySessionContext": "internal accessor/plumbing, not a user-facing control seam",
 	"agent_session:buildPreparedDisplaySessionContext": "internal accessor/plumbing, not a user-facing control seam",
@@ -279,6 +287,12 @@ const LOCKED_EXCLUSIONS: Readonly<Record<string, string>> = {
 		"internal profile and fallback-chain state, not a user-facing SDK control seam",
 	"agent_session:setDefaultFallbackRuntimeModel":
 		"internal fallback runtime bookkeeping, not a user-facing SDK control seam",
+	"agent_session:installRecoveredDefaultFallbackChain":
+		"internal recovered fallback-chain installation during session startup, not a user-facing SDK control seam",
+	"agent_session:markStartupRecoveryBindingsRequired":
+		"internal startup recovery binding marker, not a user-facing SDK control seam",
+	"agent_session:hasRecoveredDefaultFallbackChain":
+		"internal recovered fallback-chain state query, not a user-facing SDK control seam",
 	"agent_session:setCredentialPin":
 		"interactive session-scoped OAuth account selector mutation behind the locked /credential and OAuth selector surfaces; the public SDK has no credential-selection operation and must not gain credential authority implicitly",
 	"agent_session:setCredentialAuto":
@@ -287,6 +301,8 @@ const LOCKED_EXCLUSIONS: Readonly<Record<string, string>> = {
 		"internal fallback resolution bookkeeping, not a user-facing SDK control seam",
 	"agent_session:syncEagerDelegation":
 		"internal profile-derived eager delegation synchronization, not a user-facing SDK control seam",
+	"agent_session:submitUserMessage":
+		"public in-process embedder lifecycle API; direct handle surface, not an SDK transport operation",
 };
 /** Maps reviewed source seams to registry SDK operation IDs. */
 const SEAM_TO_SDK: Readonly<Record<string, string>> = {
@@ -366,6 +382,10 @@ const SEAM_TO_SDK: Readonly<Record<string, string>> = {
 	"slash_command:login": "auth.login",
 	"slash_command:clear": "context.clear",
 	"slash_command:new": "session.new",
+	// `/fork` opens the user-prompt selector, which commits via
+	// `session.branch(entryId)` (selector-controller.ts). Despite the command and
+	// keybinding name, it is NOT the exact-state `session.fork` operation.
+	"slash_command:fork": "session.branch",
 	"slash_command:compact": "compaction.run",
 	"slash_command:handoff": "session.handoff",
 	"slash_command:resume": "session.resume",
@@ -811,10 +831,17 @@ export function scanAgentSessionMethods(sourceText: string): string[] {
 			throw new Error("SDK operation inventory scanner: AgentSession class body is unbalanced.");
 
 		const methods: string[] = [];
+		const seenMethods = new Set<string>();
 		for (let memberStart = bodyStart + 1; memberStart < bodyEnd; ) {
 			const declaration = scanMethodDeclaration(tokens, memberStart, bodyEnd);
 			if (declaration) {
-				if (declaration.name) methods.push(`agent_session:${declaration.name}`);
+				if (declaration.name) {
+					const sourceId = `agent_session:${declaration.name}`;
+					if (!seenMethods.has(sourceId)) {
+						seenMethods.add(sourceId);
+						methods.push(sourceId);
+					}
+				}
 				memberStart = Math.max(memberStart + 1, declaration.end);
 				continue;
 			}
@@ -940,6 +967,7 @@ function validateRegistry(records: InventoryRecord[]): string[] {
 	const errors: string[] = [];
 	const ids = new Set<string>();
 	const sdkIds = new Set<string>();
+	const sourceIds = new Set<string>();
 	for (const operation of OPERATIONS) {
 		if (ids.has(operation.id)) errors.push(`Duplicate operation ID: ${operation.id}`);
 		ids.add(operation.id);
@@ -951,6 +979,8 @@ function validateRegistry(records: InventoryRecord[]): string[] {
 		if (operation.testIds.length === 0) errors.push(`${operation.id} is missing test IDs.`);
 	}
 	for (const record of records) {
+		if (sourceIds.has(record.sourceId)) errors.push(`Duplicate source seam: ${record.sourceId}`);
+		sourceIds.add(record.sourceId);
 		if (record.decision === "exclude") {
 			if (!record.rationale) errors.push(`${record.sourceId} exclusion lacks a locked rationale.`);
 			if (

package/scripts/vendor-markit.ts

@@ -0,0 +1,196 @@
+#!/usr/bin/env bun
+/** Reproduce the patched MIT converter; --check is strictly local and read-only. */
+import * as crypto from "node:crypto";
+import * as fs from "node:fs/promises";
+import * as os from "node:os";
+import * as path from "node:path";
+import { $ } from "bun";
+
+const packageRoot = path.resolve(import.meta.dir, "..");
+const vendorRoot = path.join(packageRoot, "vendor");
+const vendorDir = path.join(vendorRoot, "markit-ai");
+const patchPath = path.join(vendorRoot, "markit-ai.patch");
+const sourceUrl = "https://registry.npmjs.org/markit-ai/-/markit-ai-0.5.3.tgz";
+const sourceIntegrity =
+	"sha512-h4nhn6a/SNXEdc3kLVtL37TspxjUNCNL0OM7LRWxd389ZByI/B7bjNNgxFdVAT0O+H7ZekSwLdVe/lws1l2AZQ==";
+const provenanceName = "MANIFEST.json";
+const maxArchiveBytes = 16 * 1024 * 1024;
+
+interface FileHash {
+	path: string;
+	sha256: string;
+}
+
+function sha256(bytes: Uint8Array): string {
+	return crypto.createHash("sha256").update(bytes).digest("hex");
+}
+
+function selectedFile(name: string): boolean {
+	return name === "LICENSE" || name === "package.json" || name.startsWith("dist/");
+}
+
+async function inventory(directory: string): Promise<FileHash[]> {
+	const files: FileHash[] = [];
+	async function walk(relative: string): Promise<void> {
+		const absolute = path.join(directory, relative);
+		const metadata = await fs.lstat(absolute);
+		if (metadata.isDirectory()) {
+			if (relative !== "" && relative !== "dist" && !relative.startsWith("dist/")) {
+				throw new Error(`Unexpected vendor directory: ${relative}`);
+			}
+			for (const name of (await fs.readdir(absolute)).sort()) {
+				await walk(relative ? `${relative}/${name}` : name);
+			}
+		} else if (metadata.isFile()) {
+			if (relative === provenanceName) return;
+			if (!selectedFile(relative)) throw new Error(`Unexpected vendor file: ${relative}`);
+			files.push({ path: relative, sha256: sha256(await Bun.file(absolute).bytes()) });
+		} else {
+			throw new Error(`Vendor entries must be regular files or directories: ${relative}`);
+		}
+	}
+	await walk("");
+	for (const required of [
+		"LICENSE",
+		"package.json",
+		"dist/index.js",
+		"dist/index.d.ts",
+		"dist/converters/pdf/extract.js",
+		"dist/markit.js",
+	]) {
+		if (!files.some(file => file.path === required)) throw new Error(`Missing vendor file: ${required}`);
+	}
+	return files.sort((left, right) => (left.path < right.path ? -1 : left.path > right.path ? 1 : 0));
+}
+
+async function provenance(directory: string): Promise<string> {
+	return `${JSON.stringify(
+		{
+			schemaVersion: 1,
+			upstream: { name: "markit-ai", version: "0.5.3", license: "MIT", url: sourceUrl, integrity: sourceIntegrity },
+			patch: { path: "../markit-ai.patch", sha256: sha256(await Bun.file(patchPath).bytes()) },
+			files: await inventory(directory),
+		},
+		null,
+		"\t",
+	)}\n`;
+}
+
+async function verifyContents(directory: string): Promise<void> {
+	const upstream = await Bun.file(path.join(directory, "package.json")).json();
+	if (upstream.name !== "markit-ai" || upstream.version !== "0.5.3" || upstream.license !== "MIT") {
+		throw new Error("Vendored manifest must identify MIT markit-ai@0.5.3");
+	}
+	const manifest = await Bun.file(path.join(packageRoot, "package.json")).json();
+	for (const dependency of Object.keys(upstream.dependencies)) {
+		if (typeof manifest.dependencies?.[dependency] !== "string") {
+			throw new Error(`Missing direct converter runtime dependency: ${dependency}`);
+		}
+	}
+	if (manifest.dependencies.mupdf !== "1.28.0" || manifest.dependencies["markit-ai"] !== undefined) {
+		throw new Error("Converter must use vendored Markit and pinned mupdf@1.28.0");
+	}
+	const extract = await Bun.file(path.join(directory, "dist/converters/pdf/extract.js")).text();
+	const mupdfLoader = await Bun.file(path.join(directory, "dist/converters/pdf/mupdf-loader.js")).text();
+	const markit = await Bun.file(path.join(directory, "dist/markit.js")).text();
+	if (
+		/require\(["']mupdf["']\)/u.test(extract) ||
+		!extract.includes("\nlet mupdf;\n") ||
+		!extract.includes('import { loadMuPdf } from "./mupdf-loader.js";') ||
+		!extract.includes("mupdf = await loadMuPdf()") ||
+		!mupdfLoader.includes('import("mupdf")') ||
+		!extract.includes('new Error("MuPDF module initialization failed", { cause })') ||
+		!markit.includes("new AggregateError(errors.map((entry) => entry.error)") ||
+		!markit.includes("{ cause: errors[0].error }")
+	)
+		throw new Error("Vendored Markit is missing the required MuPDF/diagnostics patch");
+}
+
+async function check(): Promise<void> {
+	if (!(await fs.lstat(vendorRoot)).isDirectory()) throw new Error("Vendor root must be a real directory");
+	if (!(await fs.lstat(patchPath)).isFile()) throw new Error("Vendor patch must be a regular file");
+	// Inventory rejects symlinks before any content verification reads them.
+	const expected = await provenance(vendorDir);
+	if ((await Bun.file(path.join(vendorDir, provenanceName)).text()) !== expected) {
+		throw new Error("Markit vendor inventory or patch hash differs; regenerate from the pinned artifact");
+	}
+	await verifyContents(vendorDir);
+	process.stdout.write("Markit vendor verification passed (markit-ai@0.5.3, local hashes)\n");
+}
+
+async function download(): Promise<Uint8Array> {
+	const response = await fetch(sourceUrl, { redirect: "error", signal: AbortSignal.timeout(60_000) });
+	if (!response.ok || !response.body) throw new Error(`Pinned Markit download failed: HTTP ${response.status}`);
+	const chunks: Uint8Array[] = [];
+	let length = 0;
+	for await (const chunk of response.body) {
+		length += chunk.byteLength;
+		if (length > maxArchiveBytes) throw new Error("Pinned Markit archive exceeds size limit");
+		chunks.push(chunk);
+	}
+	const bytes = Buffer.concat(chunks, length);
+	if (`sha512-${crypto.createHash("sha512").update(bytes).digest("base64")}` !== sourceIntegrity) {
+		throw new Error("Pinned Markit archive integrity mismatch");
+	}
+	return bytes;
+}
+
+async function generate(): Promise<void> {
+	const temporaryRoot = await fs.mkdtemp(path.join(os.tmpdir(), "gjc-vendor-markit-"));
+	try {
+		const bytes = await download();
+		await Bun.write(path.join(temporaryRoot, "markit-ai-0.5.3.tgz"), bytes);
+		const source = path.join(temporaryRoot, "source");
+		await fs.mkdir(source);
+		// Read verified archive entries as data and create only regular files. Never
+		// ask an extractor to recreate upstream symlinks, permissions, or devices.
+		const entries = await new Bun.Archive(bytes).files();
+		let unpackedBytes = 0;
+		for (const [name, file] of entries) {
+			if (
+				!name.startsWith("package/") ||
+				name.includes("\\") ||
+				name.includes("\0") ||
+				name.split("/").some(part => part === "" || part === "." || part === "..")
+			) {
+				throw new Error(`Unsafe pinned archive entry: ${name}`);
+			}
+			unpackedBytes += file.size;
+			if (unpackedBytes > maxArchiveBytes) throw new Error("Pinned Markit unpacked files exceed size limit");
+			const relative = name.slice("package/".length);
+			if (!selectedFile(relative)) continue;
+			const destination = path.join(source, relative);
+			await Bun.write(destination, file);
+			await fs.chmod(destination, 0o644);
+		}
+		await $`git apply --check ${patchPath}`.cwd(source);
+		await $`git apply ${patchPath}`.cwd(source);
+		await verifyContents(source);
+		await Bun.write(path.join(source, provenanceName), await provenance(source));
+		if (!(await fs.lstat(vendorRoot)).isDirectory()) throw new Error("Vendor root must be a real directory");
+		const existing = await fs.lstat(vendorDir).catch((error: NodeJS.ErrnoException) => {
+			if (error.code === "ENOENT") return undefined;
+			throw error;
+		});
+		if (existing) {
+			// Refuse unrelated contents and symlinks rather than silently deleting them.
+			await inventory(vendorDir);
+			const oldManifest = await Bun.file(path.join(vendorDir, "package.json")).json();
+			if (oldManifest.name !== "markit-ai") throw new Error("Refusing to replace an unrelated vendor tree");
+			await fs.rm(vendorDir, { recursive: true });
+		}
+		await fs.cp(source, vendorDir, { recursive: true, force: false, errorOnExist: true });
+		await check();
+	} finally {
+		await fs.rm(temporaryRoot, { recursive: true, force: true });
+	}
+}
+
+if (import.meta.main) {
+	const args = process.argv.slice(2);
+	if (args.length !== 1 || (args[0] !== "--check" && args[0] !== "--generate")) {
+		throw new Error("Use exactly --check (offline verification) or --generate (pinned regeneration)");
+	}
+	if (args[0] === "--generate") await generate();
+	else await check();
+}

package/src/async/job-manager.ts

@@ -569,14 +569,22 @@ export class AsyncJobManager {
 	 *  instead of the last-created process-global instance (review thread P1).
 	 *  Returns TRUE when the mapping was installed (or already held by this
 	 *  manager); returns FALSE when the endpoint id is already held by a
-	 *  FOREIGN live manager — a second top-level session constructed or
-	 *  resumed under that endpoint must then fail construction instead of
-	 *  silently replacing the first manager, which would make the first
-	 *  session's tools resolve the second manager and let same-id jobs be
-	 *  queried, registered, or cancelled across sessions (review thread P1). */
+	 *  FOREIGN manager whose authority has not fully settled — a second
+	 *  top-level session constructed or resumed under that endpoint must then
+	 *  fail construction instead of silently replacing the first manager, which
+	 *  would make the first session's tools resolve the second manager and let
+	 *  same-id jobs be queried, registered, or cancelled across sessions
+	 *  (review thread P1). */
 	static registerForEndpoint(endpointId: string, manager: AsyncJobManager): boolean {
 		const holder = AsyncJobManager.#byEndpoint.get(endpointId);
-		if (holder !== undefined && holder !== manager) return false;
+		if (manager.#disposed || manager.#registrationClosed) return false;
+		if (holder !== undefined && holder !== manager) {
+			// A manager remains the endpoint owner until all authority retained
+			// past its disposal deadline has physically settled. Logical shutdown
+			// alone must not admit a replacement while late callbacks can still run.
+			if (!holder.#disposed || !holder.#disposalSettled) return false;
+			AsyncJobManager.#byEndpoint.delete(endpointId);
+		}
 		AsyncJobManager.#byEndpoint.set(endpointId, manager);
 		return true;
 	}
@@ -586,7 +594,8 @@ export class AsyncJobManager {
 		return AsyncJobManager.#byEndpoint.get(endpointId);
 	}
 
-	static unregisterForEndpoint(endpointId: string): void {
+	static unregisterForEndpoint(endpointId: string, manager?: AsyncJobManager): void {
+		if (manager !== undefined && AsyncJobManager.#byEndpoint.get(endpointId) !== manager) return;
 		AsyncJobManager.#byEndpoint.delete(endpointId);
 	}
 
@@ -619,9 +628,13 @@ export class AsyncJobManager {
 		manager: AsyncJobManager | undefined,
 	): boolean {
 		if (!manager || predecessorEndpointId === successorEndpointId) return true;
+		if (manager.#disposed || manager.#registrationClosed) return false;
 		if (AsyncJobManager.#byEndpoint.get(predecessorEndpointId) !== manager) return true;
 		const successorOwner = AsyncJobManager.#byEndpoint.get(successorEndpointId);
-		if (successorOwner !== undefined && successorOwner !== manager) return false;
+		if (successorOwner !== undefined && successorOwner !== manager) {
+			if (!successorOwner.#disposed || !successorOwner.#disposalSettled) return false;
+			AsyncJobManager.#byEndpoint.delete(successorEndpointId);
+		}
 		AsyncJobManager.#byEndpoint.delete(predecessorEndpointId);
 		AsyncJobManager.#byEndpoint.set(successorEndpointId, manager);
 		return true;
@@ -651,6 +664,7 @@ export class AsyncJobManager {
 
 	readonly #jobs = new Map<string, AsyncJob>();
 	#retainedDisposalCompletion: Promise<void> = Promise.resolve();
+	#disposePromise: Promise<boolean> | undefined;
 	readonly #deliveries: AsyncJobDelivery[] = [];
 	readonly #inFlightDeliveries: AsyncJobDelivery[] = [];
 	readonly #suppressedDeliveries = new Set<string>();
@@ -674,6 +688,8 @@ export class AsyncJobManager {
 	readonly #maxDeadLetterOverflowOwners: number;
 	#deliveryLoop: Promise<void> | undefined;
 	#disposed = false;
+	/** Set only after all authority retained past a disposal deadline settles. */
+	#disposalSettled = false;
 	#runningOwnerCleanups = false;
 	readonly #subagentRecords = new Map<string, SubagentRecord>();
 	readonly #terminalEvents = new Map<string, TerminalEvent>();
@@ -2697,7 +2713,28 @@ export class AsyncJobManager {
 	markBackgrounded(jobId: string, generation: string, reason: FoldReason): boolean {
 		const job = this.#jobs.get(jobId);
 		if (!job || job.generation !== generation) return false;
-		if (job.metadata?.backgrounded === true) return true;
+		if (job.metadata?.backgrounded === true) {
+			// A direct async start is already backgrounded, but a later `job` await
+			// can still be folded by a steer. Preserve the existing background state
+			// while recording the first fold reason and publishing its event.
+			if (job.metadata.foldReason !== undefined) return true;
+			job.metadata = { ...job.metadata, foldReason: reason };
+			for (const delivery of [...this.#deliveries, ...this.#inFlightDeliveries]) {
+				if (delivery.jobId === jobId && delivery.generation === generation) delivery.foldReason = reason;
+			}
+			this.#notifyChange();
+			const event: JobFoldEvent = { jobId, generation, reason };
+			for (const cb of this.#foldListeners) {
+				try {
+					cb(event);
+				} catch (error) {
+					logger.warn("Async job fold listener failed", {
+						error: error instanceof Error ? error.message : String(error),
+					});
+				}
+			}
+			return true;
+		}
 		job.metadata = { ...job.metadata, backgrounded: true, foldReason: reason };
 		for (const delivery of [...this.#deliveries, ...this.#inFlightDeliveries]) {
 			if (delivery.jobId === jobId && delivery.generation === generation) {
@@ -2773,6 +2810,13 @@ export class AsyncJobManager {
 	}
 
 	async dispose(options?: { timeoutMs?: number }): Promise<boolean> {
+		if (this.#disposePromise) return this.#disposePromise;
+		const disposal = this.#disposeInternal(options);
+		this.#disposePromise = disposal;
+		return disposal;
+	}
+
+	async #disposeInternal(options?: { timeoutMs?: number }): Promise<boolean> {
 		// Close registration FIRST, then run owner cleanups, and only then mark the
 		// manager disposed. Setting #disposed before the cleanups made
 		// #ensureDeliveryLoop a no-op, so a failure an owner cleanup settled through
@@ -2865,6 +2909,13 @@ export class AsyncJobManager {
 		this.#notifyChange();
 		this.#changeListeners.clear();
 		this.#foldListeners.clear();
+		const releaseEndpointOwnership = (): void => {
+			this.#disposalSettled = true;
+			AsyncJobManager.unregisterManager(this);
+			if (AsyncJobManager.instance() === this) AsyncJobManager.setInstance(undefined);
+		};
+		if (disposalCompleted) releaseEndpointOwnership();
+		else void this.#retainedDisposalCompletion.then(releaseEndpointOwnership);
 		return disposalCompleted;
 	}
 

package/src/cli/daemon-cli.ts

@@ -12,26 +12,28 @@ import type {
 	DaemonKind,
 	DaemonOperationOptions,
 	DaemonOperationResult,
+	DaemonStatus,
 } from "../daemon/control-types";
 import {
 	DAEMON_ACTION_TOKENS,
-	DAEMON_EXIT,
+	daemonOperationOutcome,
 	formatDaemonResult,
 	formatDaemonStatus,
 	resolveDaemonAction,
 } from "../daemon/operator-contract";
 import { runChatDaemonInternal } from "../sdk/bus/chat-daemon-cli";
+import { PublicCommandFailure, type PublicDaemonTargetOutcome } from "./public-command-errors";
 
 export type DaemonCliAction = "list" | "status" | "stop" | "restart";
 export type DaemonInternalCliAction = "discord-internal" | "slack-internal";
 export type DaemonCommandAction = DaemonCliAction | DaemonInternalCliAction;
 
-export class UnknownDaemonKindError extends Error {
+export class UnknownDaemonKindError extends PublicCommandFailure {
 	constructor(
 		readonly kinds: readonly string[],
 		readonly knownKinds: readonly DaemonKind[],
 	) {
-		super(`Unknown daemon kind(s): ${kinds.join(", ")}. Known kinds: ${knownKinds.join(", ")}.`);
+		super({ kind: "operation_failed", proof: "pre-effect" });
 		this.name = "UnknownDaemonKindError";
 	}
 }
@@ -60,6 +62,7 @@ export interface DaemonCommandArgs {
 export interface DaemonCommandDeps {
 	settings?: Settings;
 	controllers?: BuiltInDaemonController[];
+	/** Internal update orchestration retains result rendering and failure aggregation. */
 	setExitCode?: (code: number) => void;
 }
 
@@ -131,15 +134,36 @@ export async function runDaemonCommand(cmd: DaemonCommandArgs, deps: DaemonComma
 	}
 	const unknownKinds = cmd.kinds.filter(kind => !(KNOWN_KINDS as readonly string[]).includes(kind));
 	if (unknownKinds.length > 0) throw new UnknownDaemonKindError(unknownKinds, KNOWN_KINDS);
+	// Settings and controller construction failures are NOT an availability
+	// condition. Malformed configuration, permission/IO errors, and programming
+	// errors are permanent and each needs its own root cause: collapsing them into
+	// `unavailable` tells an operator (or an AI caller) to retry a failure that
+	// will never succeed. Let them propagate to the normal CLI error rendering,
+	// which is the pre-existing contract for this path.
 	const settings = deps.settings ?? (await Settings.init());
-	const controllers = deps.controllers ?? selectDaemonControllers(settings, cmd.kinds, cmd.all);
+	const controllers: BuiltInDaemonController[] =
+		deps.controllers ?? selectDaemonControllers(settings, cmd.kinds, cmd.all);
 
 	if (cmd.action === "list" || cmd.action === "status") {
-		const statuses = await Promise.all(controllers.map(c => c.status()));
-		if (cmd.json) {
-			process.stdout.write(`${JSON.stringify(statuses, null, 2)}\n`);
-		} else {
-			process.stdout.write(`${statuses.map(s => formatDaemonStatus(s, { verbose: cmd.verbose })).join("\n")}\n`);
+		const statusResults = await Promise.allSettled(controllers.map(controller => controller.status()));
+		const statuses: DaemonStatus[] = [];
+		const failedTargets: PublicDaemonTargetOutcome[] = [];
+		for (const [index, result] of statusResults.entries()) {
+			if (result.status === "fulfilled") statuses.push(result.value);
+			else failedTargets.push({ kind: controllers[index]!.kind, outcome: "unknown" });
+		}
+		if (failedTargets.length > 0) {
+			throw new PublicCommandFailure({
+				kind: "daemon_mixed",
+				proof: "pre-effect",
+				targets: failedTargets,
+				partialStatuses: statuses,
+			});
+		}
+		if (statuses.length > 0) {
+			if (cmd.json) process.stdout.write(`${JSON.stringify(statuses, null, 2)}\n`);
+			else
+				process.stdout.write(`${statuses.map(s => formatDaemonStatus(s, { verbose: cmd.verbose })).join("\n")}\n`);
 		}
 		return;
 	}
@@ -152,19 +176,30 @@ export async function runDaemonCommand(cmd: DaemonCommandArgs, deps: DaemonComma
 		allowDisabledNoop: cmd.allowDisabledNoop,
 	};
 	const results: DaemonOperationResult[] = [];
-	for (const controller of controllers) {
-		results.push(cmd.action === "restart" ? await controller.reload(opts) : await controller.stop(opts));
+	const targets: PublicDaemonTargetOutcome[] = [];
+	for (const [index, controller] of controllers.entries()) {
+		let result: DaemonOperationResult;
+		try {
+			result = cmd.action === "restart" ? await controller.reload(opts) : await controller.stop(opts);
+		} catch {
+			targets.push({ kind: controller.kind, outcome: "unknown" });
+			for (const pending of controllers.slice(index + 1))
+				targets.push({ kind: pending.kind, outcome: "not-applied" });
+			// Completed targets keep their full results: the envelope warns against
+			// replaying applied mutations, so it must carry the resulting state the
+			// caller has to reconcile against.
+			throw new PublicCommandFailure({ kind: "daemon_mixed", targets, partialResults: results });
+		}
+		results.push(result);
+		targets.push({ kind: controller.kind, outcome: daemonOperationOutcome(result) });
 	}
+	const failed = results.some(result => !result.ok);
+	if (failed && !deps.setExitCode)
+		throw new PublicCommandFailure({ kind: "daemon_mixed", targets, partialResults: results });
 	if (cmd.json) {
 		process.stdout.write(`${JSON.stringify(results, null, 2)}\n`);
 	} else {
 		process.stdout.write(`${results.map(formatDaemonResult).join("\n")}\n`);
 	}
-	if (results.some(r => !r.ok))
-		(
-			deps.setExitCode ??
-			(code => {
-				process.exitCode = code;
-			})
-		)(DAEMON_EXIT.failure);
+	if (failed) deps.setExitCode?.(1);
 }