@gajae-code/coding-agent 0.10.2 → 0.11.1

package/src/cli.ts

@@ -9,6 +9,7 @@ import { Args, type CliConfig, Command, type CommandEntry, Flags, run } from "@g
 import { APP_NAME, formatBunRuntimeError, MIN_BUN_VERSION, VERSION } from "@gajae-code/utils/dirs";
 import { runFixtureReport } from "./cli/fixture-report";
 import { isTmuxOwnerIsolationCliArgv, runTmuxOwnerIsolationCliFromStdin } from "./gjc-runtime/tmux-owner-isolation-cli";
+import { runChatDaemonInternal } from "./sdk/bus/chat-daemon-cli";
 
 if (Bun.semver.order(Bun.version, MIN_BUN_VERSION) < 0) {
 	process.stderr.write(
@@ -41,6 +42,7 @@ export const commands: CommandEntry[] = [
 	{ name: "config", load: () => import("./commands/config").then(m => m.default) },
 	{ name: "stats", load: () => import("./commands/stats").then(m => m.default) },
 	{ name: "notify", load: () => import("./commands/notify").then(m => m.default) },
+	{ name: "sdk", load: () => import("./commands/sdk").then(m => m.default) },
 	{ name: "daemon", load: () => import("./commands/daemon").then(m => m.default) },
 	{ name: "web-search", aliases: ["q"], load: () => import("./commands/web-search").then(m => m.default) },
 	{ name: "local-provider", load: () => import("./commands/local-provider").then(m => m.default) },
@@ -123,6 +125,18 @@ async function runNotifyDaemonInternalFastPath(argv: string[]): Promise<void> {
 	await runNotifyCommand(cmd);
 }
 
+function isChatDaemonInternalFastPath(argv: string[]): boolean {
+	return argv[0] === "daemon" && (argv[1] === "discord-internal" || argv[1] === "slack-internal");
+}
+
+async function runChatDaemonInternalFastPath(argv: string[]): Promise<void> {
+	const action = argv[1];
+	if (action !== "discord-internal" && action !== "slack-internal") {
+		throw new Error("invalid chat daemon internal fast path");
+	}
+	await runChatDaemonInternal(action === "discord-internal" ? "discord" : "slack", argv.slice(2));
+}
+
 function rootFixtureArg(argv: string[]): { present: boolean; id: string | undefined } {
 	for (let i = 0; i < argv.length; i++) {
 		const arg = argv[i];
@@ -175,10 +189,11 @@ export class RootHelpCommand extends Command {
 		}),
 		"system-prompt": Flags.string({ description: "System prompt (default: coding assistant prompt)" }),
 		"append-system-prompt": Flags.string({ description: "Append text or file contents to the system prompt" }),
+		"mcp-config": Flags.string({ description: "Tools-only MCP config file (absolute path)" }),
 		"allow-home": Flags.boolean({ description: "Allow starting in ~ without auto-switching to a temp dir" }),
 		mode: Flags.string({
-			description: "Output mode: text (default), json, rpc, acp, rpc-ui, or bridge",
-			options: ["text", "json", "rpc", "acp", "rpc-ui", "bridge"],
+			description: "Output mode: text (default), json, or acp",
+			options: ["text", "json", "acp"],
 		}),
 		print: Flags.boolean({ char: "p", description: "Non-interactive mode: process prompt and exit" }),
 		continue: Flags.boolean({ char: "c", description: "Continue previous session" }),
@@ -313,6 +328,10 @@ export async function runCli(argv: string[]): Promise<void> {
 		await runNotifyDaemonInternalFastPath(argv);
 		return;
 	}
+	if (isChatDaemonInternalFastPath(argv)) {
+		await runChatDaemonInternalFastPath(argv);
+		return;
+	}
 	if (argv[0] === "--smoke-test") {
 		await runSmokeTest();
 		return;

package/src/commands/daemon.ts

@@ -2,14 +2,22 @@
  * Manage GJC background daemons (status/list/stop/reload).
  */
 import { Args, Command, Flags } from "@gajae-code/utils/cli";
-import { type DaemonCliAction, type DaemonCommandArgs, runDaemonCommand } from "../cli/daemon-cli";
+import {
+	type DaemonCommandAction,
+	type DaemonCommandArgs,
+	isDaemonInternalAction,
+	runDaemonCommand,
+} from "../cli/daemon-cli";
 import type { DaemonKind } from "../daemon/control-types";
 import { DAEMON_ACTION_TOKENS, resolveDaemonAction } from "../daemon/operator-contract";
 import { initTheme } from "../modes/theme/theme";
+import { runSdkSessionCli } from "../sdk/cli";
+
+const ACTIONS = [...DAEMON_ACTION_TOKENS, "discord-internal", "slack-internal", "session"] as const;
 
 export default class Daemon extends Command {
 	static description =
-		"Manage GJC background daemons. Routine use: `gjc daemon status` to check, `gjc daemon restart` to reload (spawns one if none is running). `stop`/`list` and the escalation flags below are advanced primitives.";
+		"Manage GJC background daemons and SDK sessions. Routine use: `gjc daemon status` to check, `gjc daemon restart` to reload (spawns one if none is running). `stop`/`list` and the escalation flags below are advanced primitives.";
 
 	static examples = [
 		"# Check the daemon (concise per-daemon result)\n  gjc daemon status",
@@ -23,7 +31,7 @@ export default class Daemon extends Command {
 		action: Args.string({
 			description: "Daemon action (status, restart, reload, stop, list)",
 			required: false,
-			options: DAEMON_ACTION_TOKENS as string[],
+			options: [...ACTIONS] as string[],
 		}),
 		kind: Args.string({ description: "Daemon kind(s) to target", required: false, multiple: true }),
 	};
@@ -36,13 +44,46 @@ export default class Daemon extends Command {
 		"graceful-timeout-ms": Flags.integer({ description: "Cooperative stop timeout before escalation" }),
 		"kill-timeout-ms": Flags.integer({ description: "Wait for old pid death after SIGKILL" }),
 		"spawn-if-stopped": Flags.boolean({ description: "On reload, spawn even when no daemon is running" }),
+		smoke: Flags.boolean({ description: "Internal: run worker smoke without configuration or network" }),
+		"owner-id": Flags.string({ description: "Internal: daemon owner id" }),
+		"agent-dir": Flags.string({ description: "Internal: daemon state directory" }),
+		op: Flags.string({ description: "SDK control or global operation" }),
+		"idempotency-key": Flags.string({ description: "Caller idempotency key required for SDK lifecycle globals" }),
+		"json-input": Flags.string({ description: "SDK request JSON object" }),
+		"json-input-file": Flags.string({ description: "Read SDK request JSON from a 0600 file" }),
+		"json-input-stdin": Flags.boolean({ description: "Read SDK request JSON from standard input" }),
+		confirm: Flags.boolean({ description: "Confirm a destructive SDK control operation" }),
+		query: Flags.string({ description: "SDK query name" }),
+		cursor: Flags.string({ description: "SDK query continuation cursor" }),
+		"show-endpoint-credential": Flags.boolean({ description: "Allow session.get_endpoint secret output" }),
+		yes: Flags.boolean({ description: "Confirm endpoint credential output on a TTY" }),
 	};
 
 	async run(): Promise<void> {
 		const { args, flags } = await this.parse(Daemon);
-		const action = (resolveDaemonAction(args.action) ?? "status") as DaemonCliAction;
-		const kinds = (Array.isArray(args.kind) ? args.kind : args.kind ? [args.kind] : []) as DaemonKind[];
+		const rawAction = args.action ?? "status";
+		const positional = Array.isArray(args.kind) ? args.kind : args.kind ? [args.kind] : [];
 		const flagRec = flags as Record<string, unknown>;
+		if (rawAction === "session") {
+			await runSdkSessionCli({
+				action: positional[0],
+				sessionId: positional[1],
+				operation: flagRec.op as string | undefined,
+				query: flagRec.query as string | undefined,
+				jsonInput: flagRec["json-input"] as string | undefined,
+				jsonInputFile: flagRec["json-input-file"] as string | undefined,
+				jsonInputStdin: Boolean(flagRec["json-input-stdin"]),
+				confirm: Boolean(flagRec.confirm),
+				idempotencyKey: flagRec["idempotency-key"] as string | undefined,
+				cursor: flagRec.cursor as string | undefined,
+				showEndpointCredential: Boolean(flagRec["show-endpoint-credential"]),
+				yes: Boolean(flagRec.yes),
+				agentDir: flagRec["agent-dir"] as string | undefined,
+			});
+			return;
+		}
+		const action = (resolveDaemonAction(rawAction) ?? rawAction) as DaemonCommandAction;
+		const kinds = positional as DaemonKind[];
 		const cmd: DaemonCommandArgs = {
 			action,
 			kinds,
@@ -53,9 +94,12 @@ export default class Daemon extends Command {
 			gracefulTimeoutMs: flagRec["graceful-timeout-ms"] as number | undefined,
 			killTimeoutMs: flagRec["kill-timeout-ms"] as number | undefined,
 			spawnIfStopped: flagRec["spawn-if-stopped"] as boolean | undefined,
+			smoke: Boolean(flags.smoke),
+			ownerId: flagRec["owner-id"] as string | undefined,
+			agentDir: flagRec["agent-dir"] as string | undefined,
 		};
 
-		await initTheme();
+		if (!isDaemonInternalAction(action)) await initTheme();
 		await runDaemonCommand(cmd);
 	}
 }

package/src/commands/harness.ts

@@ -39,7 +39,7 @@ import { type ResolvedOwner, RuntimeOwner, resolveOwner, resolveOwnerLive } from
 import { preserveDirtyWorktree } from "../harness-control-plane/preserve";
 import { RECEIPT_SPOOL_DIR_ENV } from "../harness-control-plane/receipt-spool";
 import { buildReceipt, requiresVanishBeforeAction, type VanishEvidence } from "../harness-control-plane/receipts";
-import { GajaeCodeRpc } from "../harness-control-plane/rpc-adapter";
+import { createSdkSessionTransport, spawnNormalHarnessSession } from "../harness-control-plane/sdk-transport";
 import { classifyLeaseStatus, readLease } from "../harness-control-plane/session-lease";
 import { buildResponse, buildStateView, submitUnavailableReason } from "../harness-control-plane/state-machine";
 import {
@@ -50,7 +50,6 @@ import {
 	rememberHarnessSessionRoot,
 	resolveHarnessRoot,
 	resolveHarnessSessionRoot,
-	sessionPaths,
 	writeReceiptImmutable,
 	writeSessionState,
 } from "../harness-control-plane/storage";
@@ -66,7 +65,7 @@ import {
 	type SessionHandle,
 	type SessionState,
 } from "../harness-control-plane/types";
-import { SPAWN_PROVENANCE_ENV } from "../notifications/config";
+import { SPAWN_PROVENANCE_ENV } from "../sdk/bus/config";
 
 const PRIVATE_OWNER_CONTROL_FIELDS = new Set([
 	"socket_key",
@@ -546,6 +545,8 @@ interface OwnerSpawnResult {
 	socketKey: string | null;
 	fallbackReason: string | null;
 	blockerReason: string | null;
+	/** Exact-PID reap proof for a direct detached-owner child declared not-live (no orphan). */
+	detachedOwnerReaped?: { pid: number; verified: boolean } | null;
 }
 
 function shellQuote(value: string): string {
@@ -630,6 +631,12 @@ function scopedBootstrapReceipt(stdout: Uint8Array): ScopedBootstrapReceipt | nu
 	}
 }
 
+function ownerIsolationPlatform(): NodeJS.Platform {
+	return process.platform === "linux" || process.env.GJC_HARNESS_TEST_ASSUME_LINUX_OWNER_ISOLATION !== "1"
+		? process.platform
+		: "linux";
+}
+
 function portableProcessStartTime(pid: number): string | null {
 	if (process.platform === "linux") return null;
 	const configured = process.env.GJC_HARNESS_PROCESS_START_COMMAND;
@@ -644,7 +651,11 @@ function portableProcessStartTime(pid: number): string | null {
 			return null;
 		}
 	}
-	const result = Bun.spawnSync([...command, String(pid)], { stdout: "pipe", stderr: "ignore" });
+	const result = Bun.spawnSync([...command, String(pid)], {
+		stdout: "pipe",
+		stderr: "ignore",
+		env: { ...process.env, LC_ALL: "C", LANG: "C" },
+	});
 	if (result.exitCode !== 0) return null;
 	const value = result.stdout.toString();
 	const line = value.endsWith("\n") ? value.slice(0, -1) : value;
@@ -801,36 +812,40 @@ export default class Harness extends Command {
 	/** Detached owner daemon (spawned by `start --detach`). Runs until retired or signalled. */
 	async #runOwner(root: string, input: Record<string, unknown>, flagSession: string | undefined): Promise<void> {
 		const sessionId = requireSessionId(input, flagSession);
-		const sessionDir = sessionPaths(root, sessionId).gjcSessionDir;
-		// Optional rpc command override (tests / non-default hosts); defaults to `gjc --mode rpc`.
-		const override = process.env.GJC_HARNESS_RPC_COMMAND;
-		const command = override ? (JSON.parse(override) as string[]) : undefined;
-		// Mark the RPC owner as a GJC-spawned child (canonical provenance marker)
-		// so `notifications.sessionScope = "primary"` suppresses its notification
-		// endpoint/topic; default `all` preserves historical auto-on behavior.
-		const rpc = new GajaeCodeRpc({
-			sessionDir,
-			command,
-			env: { ...process.env, [SPAWN_PROVENANCE_ENV]: sessionId },
-		});
-		const owner = new RuntimeOwner({ root, sessionId, rpc });
+		const state = await loadState(root, sessionId);
+		const previousSpawnProvenance = process.env[SPAWN_PROVENANCE_ENV];
+		process.env[SPAWN_PROVENANCE_ENV] = sessionId;
+		let transport: Awaited<ReturnType<typeof createSdkSessionTransport>>;
+		try {
+			transport = await createSdkSessionTransport({
+				repo: state.handle.workspace,
+				sessionId,
+				spawn: () => spawnNormalHarnessSession(state.handle.workspace, sessionId),
+			});
+		} finally {
+			if (previousSpawnProvenance === undefined) delete process.env[SPAWN_PROVENANCE_ENV];
+			else process.env[SPAWN_PROVENANCE_ENV] = previousSpawnProvenance;
+		}
+		const owner = new RuntimeOwner({ root, sessionId, transport });
 		const info = await owner.start();
 		writeJson({ ok: true, owner: info });
 		await new Promise<void>(resolve => {
 			const stop = (): void => {
 				clearInterval(timer);
+				process.removeListener("SIGTERM", stop);
+				process.removeListener("SIGINT", stop);
 				resolve();
 			};
-			const timer = setInterval(async () => {
-				const resolved = await resolveOwner(root, sessionId);
-				if (!resolved.live) stop();
+			const timer = setInterval(() => {
+				void resolveOwner(root, sessionId).then(resolved => {
+					if (!resolved.live) stop();
+				});
 			}, 500);
 			timer.unref?.();
 			process.on("SIGTERM", stop);
 			process.on("SIGINT", stop);
 		});
 		await owner.stop();
-		process.exit(0);
 	}
 
 	#buildOwnerCommand(sessionId: string): string[] {
@@ -841,7 +856,7 @@ export default class Harness extends Command {
 	}
 
 	async #waitForOwner(root: string, sessionId: string): Promise<boolean> {
-		for (let i = 0; i < 100; i++) {
+		for (let i = 0; i < 160; i++) {
 			const owner = await resolveOwner(root, sessionId);
 			if (owner.live && owner.socketPath) {
 				try {
@@ -855,6 +870,38 @@ export default class Harness extends Command {
 		}
 		return false;
 	}
+	/**
+	 * Reap an exact detached-owner child the parent spawned but declared not-live. The parent
+	 * owns this PID's lifecycle (it spawned it), so shutdown is exact-owner scoped: SIGTERM, a
+	 * bounded grace wait, then SIGKILL, then verify the SAME PID exited via its exit promise.
+	 * Never name-based — the spawned Subprocess pins the exact owner identity, so a not-live
+	 * declaration must not orphan a daemon the parent brought into being.
+	 */
+	async #reapDetachedOwner(
+		child: Bun.Subprocess<"ignore", "ignore", "ignore">,
+	): Promise<{ pid: number; verified: boolean }> {
+		// A resolved exit promise proves the PID is gone; a rejection is NOT proof of exit (it may
+		// surface an error observing the subprocess), so map it to false and let the SIGKILL
+		// escalation + cleanup-uncertain surfacing handle the uncertainty.
+		const exited = child.exited.then(
+			() => true,
+			() => false,
+		);
+		const send = (signal: NodeJS.Signals): void => {
+			try {
+				child.kill(signal);
+			} catch {
+				// Kill may fail if the child already exited; the exited race below is authoritative.
+			}
+		};
+		send("SIGTERM");
+		let verified = await Promise.race([exited, Bun.sleep(2000).then(() => false)]);
+		if (!verified) {
+			send("SIGKILL");
+			verified = await Promise.race([exited, Bun.sleep(1000).then(() => false)]);
+		}
+		return { pid: child.pid, verified };
+	}
 
 	async #harnessOwnerIsolationProbe(tmuxCommand: string): Promise<OwnerIsolationProbe> {
 		return {
@@ -862,6 +909,7 @@ export default class Harness extends Command {
 				process.env.GJC_HARNESS_TEST_CALLER_CGROUP ??
 				(await fs.readFile("/proc/self/cgroup", "utf8").catch(() => null)),
 			probeServer: async (socketKey, tmuxControlArgv): Promise<TmuxServerProof> => {
+				const platform = ownerIsolationPlatform();
 				if (!socketKey || socketKey.length > 128) return { state: "unverifiable" };
 				const controlArgv = tmuxControlArgv ?? [tmuxCommand, "-L", socketKey];
 				if (controlArgv.length < 3 || controlArgv[0] !== tmuxCommand || !controlArgv.includes("-L")) {
@@ -878,20 +926,16 @@ export default class Harness extends Command {
 				if (!Number.isSafeInteger(pid) || pid <= 0) return { state: "unverifiable" };
 				const cgroupText =
 					process.env.GJC_HARNESS_TEST_SERVER_CGROUP ??
-					(process.platform === "linux"
-						? await fs.readFile(`/proc/${pid}/cgroup`, "utf8").catch(() => null)
-						: null);
+					(platform === "linux" ? await fs.readFile(`/proc/${pid}/cgroup`, "utf8").catch(() => null) : null);
 				const testStartTime = process.env.GJC_HARNESS_TEST_SERVER_START_TIME;
 				const stat =
-					testStartTime || process.platform !== "linux"
+					testStartTime || platform !== "linux"
 						? null
 						: await fs.readFile(`/proc/${pid}/stat`, "utf8").catch(() => null);
-				const cgroup = classifyCgroup({ platform: process.platform, cgroupText });
+				const cgroup = classifyCgroup({ platform, cgroupText });
 				const startTime =
 					testStartTime ??
-					(process.platform === "linux"
-						? ownerProcessStartTime(process.platform, stat)
-						: portableProcessStartTime(pid));
+					(platform === "linux" ? ownerProcessStartTime(platform, stat) : portableProcessStartTime(pid));
 				if (!startTime) return { state: "unverifiable", pid, cgroup };
 				return {
 					state:
@@ -996,7 +1040,8 @@ export default class Harness extends Command {
 		} catch {
 			return { started: false, sessionName, socketKey, reason: "tmux-owner-generation_unverifiable" };
 		}
-		if (process.platform !== "linux" && !portableProcessStartTime(process.pid))
+		const platform = ownerIsolationPlatform();
+		if (platform !== "linux" && !portableProcessStartTime(process.pid))
 			return { started: false, sessionName, socketKey, reason: "tmux-owner-generation_unverifiable" };
 		await fs.mkdir(path.join(ownerStateDir, sessionId, "owner-lifecycle"), { recursive: true, mode: 0o700 });
 		const ownerGeneration = randomUUID();
@@ -1008,10 +1053,10 @@ export default class Harness extends Command {
 		];
 		if (process.env[RECEIPT_SPOOL_DIR_ENV])
 			envAssignments.push(`${RECEIPT_SPOOL_DIR_ENV}=${shellQuote(process.env[RECEIPT_SPOOL_DIR_ENV])}`);
-		if (process.env.GJC_HARNESS_RPC_COMMAND)
-			envAssignments.push(`GJC_HARNESS_RPC_COMMAND=${shellQuote(process.env.GJC_HARNESS_RPC_COMMAND)}`);
 		if (process.env.GJC_HARNESS_TEST_NODE_MODULES)
 			envAssignments.push(`GJC_HARNESS_TEST_NODE_MODULES=${shellQuote(process.env.GJC_HARNESS_TEST_NODE_MODULES)}`);
+		if (process.env.GJC_SDK_DISABLE)
+			envAssignments.push(`GJC_SDK_DISABLE=${shellQuote(process.env.GJC_SDK_DISABLE)}`);
 		const shellCommand = `exec env ${envAssignments.join(" ")} ${this.#buildOwnerCommand(sessionId).map(shellQuote).join(" ")}`;
 		const probe = await this.#harnessOwnerIsolationProbe(tmuxCommand);
 		const probeServer = probe.probeServer;
@@ -1036,7 +1081,7 @@ export default class Harness extends Command {
 			{
 				schema_version: 1,
 				op: "plan",
-				platform: process.platform,
+				platform,
 				session_id: sessionId,
 				owner_generation: ownerGeneration,
 				baseline,
@@ -1216,6 +1261,7 @@ export default class Harness extends Command {
 				...(process.env.GJC_HARNESS_TEST_NODE_MODULES
 					? { GJC_HARNESS_TEST_NODE_MODULES: process.env.GJC_HARNESS_TEST_NODE_MODULES }
 					: {}),
+				...(process.env.GJC_SDK_DISABLE ? { GJC_SDK_DISABLE: process.env.GJC_SDK_DISABLE } : {}),
 			},
 			stdout: "ignore",
 			stderr: "ignore",
@@ -1223,6 +1269,7 @@ export default class Harness extends Command {
 		});
 		child.unref();
 		const live = await this.#waitForOwner(root, sessionId);
+		const detachedOwnerReaped = live ? null : await this.#reapDetachedOwner(child);
 		return {
 			live,
 			runtime: "detached",
@@ -1230,6 +1277,7 @@ export default class Harness extends Command {
 			socketKey: null,
 			fallbackReason,
 			blockerReason: live ? null : "detached-owner-not-live",
+			...(detachedOwnerReaped ? { detachedOwnerReaped } : {}),
 		};
 	}
 
@@ -1274,7 +1322,7 @@ export default class Harness extends Command {
 			base: typeof input.base === "string" ? input.base : null,
 			issueOrPr: preflight.normalizedIssueOrPr,
 			processHandle: { kind: "runtime-owner", ownerId: null, pid: null },
-			rpcHandle: { kind: "rpc-subprocess", pid: null, sessionDir: `${root}/sessions/${sessionId}/gjc-session` },
+			sdkHandle: { kind: "sdk-session-endpoint", sessionId },
 			ownerHandle: { leasePath, endpoint: null, heartbeatAt: null },
 			routerHandle: { kind: "default-in-owner", policy: "default-fallback", eventsPath },
 			viewportHandle: { kind: "event-monitor", tmuxSessionName: null, viewOnly: true },
@@ -1299,6 +1347,7 @@ export default class Harness extends Command {
 		let ownerFallbackReason: string | null = null;
 		let ownerBlockerReason: string | null = null;
 		let ownerSocketKey: string | null = null;
+		let ownerDetachedReaped: { pid: number; verified: boolean } | null = null;
 		if (input.detach === true) {
 			const ownerSpawn = await this.#spawnDetachedOwner(root, sessionId, workspace);
 			ownerLive = ownerSpawn.live;
@@ -1306,6 +1355,7 @@ export default class Harness extends Command {
 			ownerFallbackReason = ownerSpawn.fallbackReason;
 			ownerBlockerReason = ownerSpawn.blockerReason;
 			ownerSocketKey = ownerSpawn.socketKey;
+			ownerDetachedReaped = ownerSpawn.detachedOwnerReaped ?? null;
 			handle.viewportHandle = {
 				kind: "event-monitor",
 				tmuxSessionName: ownerSpawn.tmuxSessionName,
@@ -1330,7 +1380,13 @@ export default class Harness extends Command {
 		// A live endpoint never proves a failed tmux launch safe: preserve the isolation/provenance blocker.
 		if (ownerBlockerReason) {
 			state.lifecycle = "blocked";
-			state.blockers = [...state.blockers, ownerBlockerReason];
+			// `detached-owner-not-live` is the lifecycle status; an unverified reap (the exact
+			// spawned child never confirmed exit after SIGKILL) is a stronger, distinct signal that
+			// must not be masked by the not-live blocker alone.
+			const ownerBlockers = [ownerBlockerReason];
+			if (ownerDetachedReaped && !ownerDetachedReaped.verified)
+				ownerBlockers.push("detached-owner-cleanup-uncertain");
+			state.blockers = [...state.blockers, ...ownerBlockers];
 			state.handle = handle;
 			state.updatedAt = nowIso();
 			await writeSessionState(root, state);
@@ -1346,6 +1402,7 @@ export default class Harness extends Command {
 					...(ownerSocketKey ? { tmuxOwnerSocketKey: ownerSocketKey } : {}),
 					...(ownerFallbackReason ? { ownerFallbackReason } : {}),
 					...(ownerBlockerReason ? { reason: ownerBlockerReason } : {}),
+					...(ownerDetachedReaped ? { detachedOwnerReaped: ownerDetachedReaped } : {}),
 				},
 				!ownerBlockerReason,
 			),

package/src/commands/launch.ts

@@ -105,12 +105,15 @@ export default class Index extends Command {
 		"append-system-prompt": Flags.string({
 			description: "Append text or file contents to the system prompt",
 		}),
+		"mcp-config": Flags.string({
+			description: "Tools-only MCP config file (absolute path)",
+		}),
 		"allow-home": Flags.boolean({
 			description: "Allow starting in ~ without auto-switching to a temp dir",
 		}),
 		mode: Flags.string({
-			description: "Output mode: text (default), json, rpc, acp, rpc-ui, or bridge",
-			options: ["text", "json", "rpc", "acp", "rpc-ui", "bridge"],
+			description: "Output mode: text (default), json, or acp",
+			options: ["text", "json", "acp"],
 		}),
 		print: Flags.boolean({
 			char: "p",

package/src/commands/mcp-serve.ts

@@ -5,13 +5,15 @@ import {
 	COORDINATOR_MCP_TOOL_NAMES,
 } from "../coordinator/contract";
 import { runCoordinatorMcpStdio } from "../coordinator-mcp/server";
+import { runSdkMcpStdio, SDK_MCP_TOOL_NAMES } from "../sdk/mcp/server";
 
 function writeJson(value: unknown): void {
 	process.stdout.write(`${JSON.stringify(value, null, 2)}\n`);
 }
 
 export function validateMcpServeSubcommandForTest(server: string | undefined): void {
-	if (server !== "coordinator" && server !== "hermes") throw new Error(`unknown_mcp_serve_subcommand:${server ?? ""}`);
+	if (server !== "coordinator" && server !== "hermes" && server !== "sdk")
+		throw new Error(`unknown_mcp_serve_subcommand:${server ?? ""}`);
 }
 
 export default class McpServe extends Command {
@@ -19,7 +21,7 @@ export default class McpServe extends Command {
 	static strict = false;
 
 	static args = {
-		server: Args.string({ description: "MCP server to run (coordinator or hermes alias)", required: false }),
+		server: Args.string({ description: "MCP server to run (sdk, coordinator, or hermes alias)", required: false }),
 	};
 
 	static flags = {
@@ -44,17 +46,22 @@ export default class McpServe extends Command {
 		}
 
 		if (flags.check) {
-			const payload = {
-				ok: true,
-				server: { name: COORDINATOR_MCP_SERVER_NAME, protocolVersion: COORDINATOR_MCP_PROTOCOL_VERSION },
-				readOnly: true,
-				tools: [...COORDINATOR_MCP_TOOL_NAMES],
-			};
+			const payload =
+				server === "sdk"
+					? { ok: true, server: { name: "gjc-sdk-mcp" }, readOnly: false, tools: [...SDK_MCP_TOOL_NAMES] }
+					: {
+							ok: true,
+							server: { name: COORDINATOR_MCP_SERVER_NAME, protocolVersion: COORDINATOR_MCP_PROTOCOL_VERSION },
+							readOnly: true,
+							tools: [...COORDINATOR_MCP_TOOL_NAMES],
+						};
 			if (flags.json) writeJson(payload);
-			else
-				process.stdout.write(
-					`server: ${payload.server.name}\nprotocol: ${payload.server.protocolVersion}\ntools: ${payload.tools.length}\n`,
-				);
+			else process.stdout.write(`server: ${payload.server.name}\ntools: ${payload.tools.length}\n`);
+			return;
+		}
+
+		if (server === "sdk") {
+			await runSdkMcpStdio();
 			return;
 		}
 

package/src/commands/notify.ts

@@ -1,5 +1,5 @@
 /**
- * Configure Telegram notifications.
+ * Configure Telegram, Discord, or Slack notifications.
  */
 import { Args, Command, Flags } from "@gajae-code/utils/cli";
 import { type NotifyAction, type NotifyCommandArgs, runNotifyCliCommand } from "../cli/notify-cli";
@@ -8,7 +8,7 @@ import { initTheme } from "../modes/theme/theme";
 const ACTIONS: NotifyAction[] = ["setup", "status", "health", "test", "recovery", "daemon-internal"];
 
 export default class Notify extends Command {
-	static description = "Configure Telegram notifications";
+	static description = "Configure Telegram, Discord, or Slack notifications";
 
 	static args = {
 		action: Args.string({
@@ -17,7 +17,7 @@ export default class Notify extends Command {
 			options: ACTIONS,
 		}),
 		extra: Args.string({
-			description: "Additional internal args",
+			description: "Provider or additional internal args",
 			required: false,
 			multiple: true,
 		}),
@@ -27,6 +27,19 @@ export default class Notify extends Command {
 		smoke: Flags.boolean({ description: "Run hidden daemon smoke" }),
 		token: Flags.string({ description: "Telegram bot token (non-interactive setup)" }),
 		"chat-id": Flags.string({ description: "Telegram chat id to pair (non-interactive setup)" }),
+		"discord-bot-token": Flags.string({ description: "Discord bot token (non-interactive Discord setup)" }),
+		"discord-application-id": Flags.string({ description: "Discord application id (non-interactive Discord setup)" }),
+		"discord-guild-id": Flags.string({ description: "Discord guild id (non-interactive Discord setup)" }),
+		"discord-parent-channel-id": Flags.string({
+			description: "Discord parent channel id (non-interactive Discord setup)",
+		}),
+		"slack-bot-token": Flags.string({ description: "Slack bot token (non-interactive Slack setup)" }),
+		"slack-app-token": Flags.string({ description: "Slack app token (non-interactive Slack setup)" }),
+		"slack-workspace-id": Flags.string({ description: "Slack workspace id (non-interactive Slack setup)" }),
+		"slack-channel-id": Flags.string({ description: "Slack channel id (non-interactive Slack setup)" }),
+		"slack-authorized-user-id": Flags.string({
+			description: "Slack user id authorized for inbound replies and commands",
+		}),
 		redact: Flags.boolean({ description: "Enable redaction of remote notification content" }),
 		probe: Flags.boolean({ description: "notify health: probe Telegram reachability (getMe)" }),
 		message: Flags.string({ description: "notify test: custom message body" }),
@@ -47,13 +60,33 @@ export default class Notify extends Command {
 			...(agentDir ? ["--agent-dir", agentDir] : []),
 			...extra,
 		];
+		const provider = extra[0];
+		if (
+			action === "setup" &&
+			provider !== undefined &&
+			provider !== "telegram" &&
+			provider !== "discord" &&
+			provider !== "slack"
+		) {
+			throw new Error(`Unknown notification provider: ${provider}`);
+		}
 
 		const cmd: NotifyCommandArgs = {
 			action,
 			smoke: flags.smoke,
 			rawArgs,
+			provider: provider === "telegram" || provider === "discord" || provider === "slack" ? provider : undefined,
 			token: flags.token as string | undefined,
 			chatId: (flags as Record<string, unknown>)["chat-id"] as string | undefined,
+			discordBotToken: flagRec["discord-bot-token"] as string | undefined,
+			discordApplicationId: flagRec["discord-application-id"] as string | undefined,
+			discordGuildId: flagRec["discord-guild-id"] as string | undefined,
+			discordParentChannelId: flagRec["discord-parent-channel-id"] as string | undefined,
+			slackBotToken: flagRec["slack-bot-token"] as string | undefined,
+			slackAppToken: flagRec["slack-app-token"] as string | undefined,
+			slackWorkspaceId: flagRec["slack-workspace-id"] as string | undefined,
+			slackChannelId: flagRec["slack-channel-id"] as string | undefined,
+			slackAuthorizedUserId: flagRec["slack-authorized-user-id"] as string | undefined,
 			redact: Boolean(flags.redact),
 			probe: Boolean(flags.probe),
 			message: flags.message as string | undefined,