@sayknow-cli/coding-agent 0.3.11 → 0.3.13

package/src/cli/daemon-cli.ts

@@ -12,8 +12,14 @@ import type {
 	DaemonKind,
 	DaemonOperationOptions,
 	DaemonOperationResult,
-	DaemonStatus,
 } from "../daemon/control-types";
+import {
+	DAEMON_ACTION_TOKENS,
+	DAEMON_EXIT,
+	formatDaemonResult,
+	formatDaemonStatus,
+	resolveDaemonAction,
+} from "../daemon/operator-contract";
 
 export type DaemonCliAction = "list" | "status" | "stop" | "reload";
 
@@ -26,6 +32,8 @@ export interface DaemonCommandArgs {
 	gracefulTimeoutMs?: number;
 	killTimeoutMs?: number;
 	spawnIfStopped?: boolean;
+	/** Show runtime detail and the full roots list in human output. */
+	verbose?: boolean;
 }
 
 export interface DaemonCommandDeps {
@@ -33,18 +41,20 @@ export interface DaemonCommandDeps {
 	controllers?: BuiltInDaemonController[];
 }
 
-const KNOWN_ACTIONS: DaemonCliAction[] = ["list", "status", "stop", "reload"];
 const KNOWN_KINDS: DaemonKind[] = ["telegram"];
 
 export function parseDaemonArgs(argv: string[]): DaemonCommandArgs | undefined {
 	if (argv.length === 0 || argv[0] !== "daemon") return undefined;
 	const rest = argv.slice(1);
-	const action = (KNOWN_ACTIONS as string[]).includes(rest[0] ?? "") ? (rest[0] as DaemonCliAction) : "status";
-	const positional = (KNOWN_ACTIONS as string[]).includes(rest[0] ?? "") ? rest.slice(1) : rest;
+	const resolved = resolveDaemonAction(rest[0]);
+	const isActionToken = (DAEMON_ACTION_TOKENS as readonly string[]).includes(rest[0] ?? "");
+	const action = (resolved ?? "status") as DaemonCliAction;
+	const positional = isActionToken ? rest.slice(1) : rest;
 	const kinds: DaemonKind[] = [];
 	let all = false;
 	let json = false;
 	let force = false;
+	let verbose = false;
 	let gracefulTimeoutMs: number | undefined;
 	let killTimeoutMs: number | undefined;
 	let spawnIfStopped: boolean | undefined;
@@ -53,34 +63,14 @@ export function parseDaemonArgs(argv: string[]): DaemonCommandArgs | undefined {
 		if (arg === "--all") all = true;
 		else if (arg === "--json") json = true;
 		else if (arg === "--force") force = true;
+		else if (arg === "--verbose" || arg === "-v") verbose = true;
 		else if (arg === "--spawn-if-stopped") spawnIfStopped = true;
 		else if (arg === "--graceful-timeout-ms") gracefulTimeoutMs = Number.parseInt(positional[++i], 10);
 		else if (arg === "--kill-timeout-ms") killTimeoutMs = Number.parseInt(positional[++i], 10);
 		else if (!arg.startsWith("--") && (KNOWN_KINDS as string[]).includes(arg)) kinds.push(arg as DaemonKind);
 	}
-	return { action, kinds, all, json, force, gracefulTimeoutMs, killTimeoutMs, spawnIfStopped };
+	return { action, kinds, all, json, force, verbose, gracefulTimeoutMs, killTimeoutMs, spawnIfStopped };
 }
-
-function formatStatus(status: DaemonStatus): string {
-	const parts = [
-		`${status.kind}: ${status.health}`,
-		status.configured ? undefined : "(not configured)",
-		status.pid !== undefined ? `pid=${status.pid}` : undefined,
-		status.ownerId ? `owner=${status.ownerId}` : undefined,
-		status.rootCount !== undefined ? `roots=${status.rootCount}` : undefined,
-		`mode=${status.runtime.mode}`,
-	].filter(Boolean);
-	let line = parts.join(" ");
-	if (status.runtime.warning) line += `\n  warning: ${status.runtime.warning}`;
-	return line;
-}
-
-function formatResult(result: DaemonOperationResult): string {
-	const head = `${result.kind} ${result.action}: ${result.ok ? "ok" : "failed"} — ${result.message}`;
-	const warnings = result.warnings.map(w => `\n  warning: ${w}`).join("");
-	return head + warnings;
-}
-
 export async function runDaemonCommand(cmd: DaemonCommandArgs, deps: DaemonCommandDeps = {}): Promise<void> {
 	const unknownKinds = cmd.kinds.filter(kind => !(KNOWN_KINDS as string[]).includes(kind));
 	if (unknownKinds.length > 0) {
@@ -98,7 +88,7 @@ export async function runDaemonCommand(cmd: DaemonCommandArgs, deps: DaemonComma
 		if (cmd.json) {
 			process.stdout.write(`${JSON.stringify(statuses, null, 2)}\n`);
 		} else {
-			process.stdout.write(`${statuses.map(formatStatus).join("\n")}\n`);
+			process.stdout.write(`${statuses.map(s => formatDaemonStatus(s, { verbose: cmd.verbose })).join("\n")}\n`);
 		}
 		return;
 	}
@@ -116,7 +106,7 @@ export async function runDaemonCommand(cmd: DaemonCommandArgs, deps: DaemonComma
 	if (cmd.json) {
 		process.stdout.write(`${JSON.stringify(results, null, 2)}\n`);
 	} else {
-		process.stdout.write(`${results.map(formatResult).join("\n")}\n`);
+		process.stdout.write(`${results.map(formatDaemonResult).join("\n")}\n`);
 	}
-	if (results.some(r => !r.ok)) process.exitCode = 1;
+	if (results.some(r => !r.ok)) process.exitCode = DAEMON_EXIT.failure;
 }

package/src/cli/malloc-env-guard.test.ts

@@ -0,0 +1,104 @@
+import { describe, expect, it } from "bun:test";
+import {
+	buildMallocReexecArgv,
+	formatMallocEnvNotice,
+	hasMacOSMallocEnv,
+	MACOS_MALLOC_ENV_VARS,
+	MALLOC_ENV_REEXEC_GUARD,
+	shouldReexecForMacOSMallocEnv,
+} from "./malloc-env-guard";
+
+describe("hasMacOSMallocEnv", () => {
+	it("detects MallocStackLogging", () => {
+		expect(hasMacOSMallocEnv({ MallocStackLogging: "0" })).toBe(true);
+	});
+
+	it("detects MallocStackLoggingNoCompact", () => {
+		expect(hasMacOSMallocEnv({ MallocStackLoggingNoCompact: "1" })).toBe(true);
+	});
+
+	it("is false when neither var is present", () => {
+		expect(hasMacOSMallocEnv({ PATH: "/usr/bin", HOME: "/home/x" })).toBe(false);
+	});
+
+	it("is false for an empty environment", () => {
+		expect(hasMacOSMallocEnv({})).toBe(false);
+	});
+});
+
+describe("shouldReexecForMacOSMallocEnv", () => {
+	it("is true on darwin with a malloc var and no loop guard", () => {
+		expect(shouldReexecForMacOSMallocEnv({ MallocStackLogging: "0" }, "darwin")).toBe(true);
+	});
+
+	it("is false off darwin even when a malloc var is present", () => {
+		expect(shouldReexecForMacOSMallocEnv({ MallocStackLogging: "0" }, "linux")).toBe(false);
+		expect(shouldReexecForMacOSMallocEnv({ MallocStackLogging: "0" }, "win32")).toBe(false);
+	});
+
+	it("is false when the loop guard is already set (already re-exec'd)", () => {
+		expect(shouldReexecForMacOSMallocEnv({ MallocStackLogging: "0", [MALLOC_ENV_REEXEC_GUARD]: "1" }, "darwin")).toBe(
+			false,
+		);
+	});
+
+	it("is false on darwin when no malloc var is present", () => {
+		expect(shouldReexecForMacOSMallocEnv({ PATH: "/usr/bin" }, "darwin")).toBe(false);
+	});
+});
+
+describe("buildMallocReexecArgv", () => {
+	it("drops the embedded virtual entry for a POSIX compiled binary", () => {
+		expect(buildMallocReexecArgv(["/exe", "/$bunfs/root/cli", "run", "--flag"], "/exe")).toEqual([
+			"/exe",
+			"run",
+			"--flag",
+		]);
+	});
+
+	it("drops the embedded virtual entry for a Windows compiled binary", () => {
+		expect(buildMallocReexecArgv(["C:/exe.exe", "B:\\~BUN\\root\\cli", "run"], "C:/exe.exe")).toEqual([
+			"C:/exe.exe",
+			"run",
+		]);
+	});
+
+	it("drops the percent-encoded embedded virtual entry", () => {
+		expect(buildMallocReexecArgv(["/exe", "B:\\%7EBUN\\root\\cli", "run"], "/exe")).toEqual(["/exe", "run"]);
+	});
+
+	it("keeps the on-disk script for a source/dev-link run", () => {
+		expect(
+			buildMallocReexecArgv(["/usr/bin/bun", "/repo/packages/coding-agent/src/cli.ts", "run", "-x"], "/usr/bin/bun"),
+		).toEqual(["/usr/bin/bun", "/repo/packages/coding-agent/src/cli.ts", "run", "-x"]);
+	});
+
+	it("handles a source run with no user args", () => {
+		expect(buildMallocReexecArgv(["/usr/bin/bun", "/repo/cli.ts"], "/usr/bin/bun")).toEqual([
+			"/usr/bin/bun",
+			"/repo/cli.ts",
+		]);
+	});
+});
+
+describe("formatMallocEnvNotice", () => {
+	it("names both env vars and the permanent launchctl fix", () => {
+		const notice = formatMallocEnvNotice();
+		for (const name of MACOS_MALLOC_ENV_VARS) {
+			expect(notice).toContain(name);
+		}
+		expect(notice).toContain("launchctl unsetenv MallocStackLogging");
+		expect(notice).toContain("launchctl unsetenv MallocStackLoggingNoCompact");
+		expect(notice.endsWith("\n")).toBe(true);
+	});
+});
+
+describe("module constants", () => {
+	it("exposes exactly the two macOS malloc env vars", () => {
+		expect([...MACOS_MALLOC_ENV_VARS]).toEqual(["MallocStackLogging", "MallocStackLoggingNoCompact"]);
+	});
+
+	it("uses a namespaced loop-guard variable", () => {
+		expect(MALLOC_ENV_REEXEC_GUARD).toBe("SKC_MALLOC_ENV_REEXEC");
+	});
+});

package/src/cli/malloc-env-guard.ts

@@ -0,0 +1,149 @@
+/**
+ * macOS malloc-stack-logging launch boundary.
+ *
+ * On macOS, an inherited `MallocStackLogging` / `MallocStackLoggingNoCompact`
+ * environment variable (from an Xcode scheme's malloc diagnostics, Instruments,
+ * `launchctl setenv`, or a debug-attached shell) makes libmalloc print
+ *
+ *   MallocStackLogging: can't turn off malloc stack logging because it was not enabled.
+ *
+ * to the stderr of every TTY-attached process. Bun snapshots the spawn-default
+ * environment at process startup — before any JS runs — so neither
+ * `delete process.env.X` nor a real libc `unsetenv()` cleans the environment
+ * that children inherit by default (verified on Bun 1.3.14). Inside the TUI,
+ * every PTY-spawned child then repeats the warning straight into the rendered
+ * frame and corrupts the display.
+ *
+ * The only way to hand children a clean startup snapshot is to start the primary
+ * process with a clean environment. This module re-execs the exact invocation
+ * once (darwin-only) with a `filterProcessEnv`-scrubbed environment and a
+ * `SKC_MALLOC_ENV_REEXEC` loop guard, before any fast path or subprocess spawn.
+ * The re-exec'd process — and therefore every downstream lane: `Bun.spawn`
+ * defaults, `node:child_process`, the native PTY, the tmux owner, plugin
+ * installs, and subagents — starts from a clean snapshot.
+ *
+ * The initial contaminated process's own libmalloc line is emitted by libc
+ * before any JS runs and cannot be suppressed from inside the process; it
+ * appears at most once per launch. A one-time actionable notice is written to
+ * interactive stderr (outside the rendered frame) pointing at the permanent
+ * `launchctl unsetenv` fix.
+ */
+
+import { filterProcessEnv } from "@sayknow-cli/utils/env";
+import type { Subprocess } from "bun";
+
+/** Env vars that make macOS libmalloc write to a TTY when inherited. */
+export const MACOS_MALLOC_ENV_VARS = ["MallocStackLogging", "MallocStackLoggingNoCompact"] as const;
+
+/** Loop guard set on the scrubbed re-exec so it never re-execs itself again. */
+export const MALLOC_ENV_REEXEC_GUARD = "SKC_MALLOC_ENV_REEXEC";
+
+/** True when at least one macOS malloc-stack-logging var is present in `env`. */
+export function hasMacOSMallocEnv(env: Record<string, string | undefined>): boolean {
+	return MACOS_MALLOC_ENV_VARS.some(name => env[name] !== undefined);
+}
+
+/**
+ * True iff we must re-exec to escape a contaminated macOS startup snapshot:
+ * darwin, not already inside the scrubbed re-exec, and at least one malloc var
+ * present. Off darwin or on the re-exec'd child this is always false, so the
+ * common launch path pays only two cheap lookups.
+ */
+export function shouldReexecForMacOSMallocEnv(
+	env: Record<string, string | undefined>,
+	platform: NodeJS.Platform,
+): boolean {
+	return platform === "darwin" && env[MALLOC_ENV_REEXEC_GUARD] === undefined && hasMacOSMallocEnv(env);
+}
+
+/**
+ * Reconstruct the argv that re-runs the exact same program image.
+ *
+ * - Compiled single-file executable: argv[1] is the embedded virtual entry
+ *   (`/$bunfs/…` on POSIX, `B:\~BUN\…` on Windows), which must be dropped — the
+ *   executable re-embeds its own entry. Re-run `[exe, ...userArgs]`.
+ * - Source / dev-link run: argv[1] is the on-disk script that must be passed
+ *   back to the interpreter. Re-run `[interpreter, script, ...userArgs]`.
+ */
+export function buildMallocReexecArgv(argv: readonly string[], execPath: string): string[] {
+	const entry = argv[1];
+	const isCompiledEntry =
+		typeof entry === "string" && (entry.includes("/$bunfs/") || entry.includes("~BUN") || entry.includes("%7EBUN"));
+	if (isCompiledEntry) {
+		return [execPath, ...argv.slice(2)];
+	}
+	return [execPath, ...argv.slice(1)];
+}
+
+/** One-time, human-actionable notice pointing at the permanent environment fix. */
+export function formatMallocEnvNotice(): string {
+	return (
+		"sayknow-cli: detected macOS malloc-stack-logging environment variables " +
+		"(MallocStackLogging / MallocStackLoggingNoCompact); relaunching once with a " +
+		"scrubbed environment so they do not flood the terminal.\n" +
+		"  Remove them permanently with:\n" +
+		"    unset MallocStackLogging MallocStackLoggingNoCompact\n" +
+		"    launchctl unsetenv MallocStackLogging\n" +
+		"    launchctl unsetenv MallocStackLoggingNoCompact\n"
+	);
+}
+
+/**
+ * Re-exec the current process once with a scrubbed environment and propagate the
+ * child's exit code. Callers MUST gate this behind `shouldReexecForMacOSMallocEnv`.
+ *
+ * Returns the child exit code, or `null` if the re-exec could not be spawned (in
+ * which case the caller falls back to running in the current, contaminated
+ * process — degraded but functional; the native PTY boundary and
+ * `filterProcessEnv` still keep managed children clean).
+ */
+export async function reexecWithScrubbedMallocEnv(): Promise<number | null> {
+	const cleanEnv = filterProcessEnv(process.env);
+	cleanEnv[MALLOC_ENV_REEXEC_GUARD] = "1";
+	const childArgv = buildMallocReexecArgv(process.argv, process.execPath);
+
+	// Surface the diagnostic exactly once, before the TUI enters its alternate
+	// screen, and only on an interactive terminal (piped/CI stderr is not a TTY,
+	// so libmalloc stays silent there and the notice would just be noise).
+	if (process.stderr.isTTY) {
+		process.stderr.write(formatMallocEnvNotice());
+	}
+
+	let child: Subprocess;
+	try {
+		child = Bun.spawn(childArgv, {
+			env: cleanEnv,
+			stdin: "inherit",
+			stdout: "inherit",
+			stderr: "inherit",
+		});
+	} catch {
+		return null;
+	}
+
+	// Keep the wrapper alive on SIGINT/SIGTERM so it reaps the child and
+	// propagates its exit code instead of dying first, and forward the signal so
+	// the scrubbed child terminates too. Interactive Ctrl-C is delivered to the
+	// whole foreground process group (and the TUI's raw mode turns it into a 0x03
+	// byte, not a signal, anyway), so re-forwarding is a harmless no-op once the
+	// child is already handling or exiting. Targeted delivery — `kill -INT <pid>`
+	// or a supervisor's `child.kill("SIGINT")` — reaches only the wrapper, so
+	// without forwarding the launch would be uncancellable outside a terminal.
+	const forwardSignal = (signal: NodeJS.Signals) => () => {
+		try {
+			child.kill(signal);
+		} catch {
+			// Child already gone; nothing to forward.
+		}
+	};
+	const onSigint = forwardSignal("SIGINT");
+	const onSigterm = forwardSignal("SIGTERM");
+	process.on("SIGINT", onSigint);
+	process.on("SIGTERM", onSigterm);
+	try {
+		return await child.exited;
+	} finally {
+		process.off("SIGINT", onSigint);
+		process.off("SIGTERM", onSigterm);
+	}
+}

package/src/cli/mcp-cli.ts

@@ -37,14 +37,27 @@ interface ScopedPath {
 	path: string;
 }
 
+interface RuntimeDisclosure {
+	runtimeStatus: "storage-only";
+	runtimeLoadedByStandalone: false;
+	runtimeNote: string;
+}
+
 interface RedactedServerEntry {
 	name: string;
 	config: MCPServerConfig;
 }
 
+interface RuntimeRedactedServerEntry extends RedactedServerEntry, RuntimeDisclosure {}
+
 const REDACTED = "<redacted>";
 const SENSITIVE_KEY_PATTERN =
 	/(?:token|secret|key|credential|password|passwd|pwd|authorization|auth|bearer|cookie|session)/i;
+const STORAGE_ONLY_RUNTIME_DISCLOSURE: RuntimeDisclosure = {
+	runtimeStatus: "storage-only",
+	runtimeLoadedByStandalone: false,
+	runtimeNote: "Stored MCP registrations are not loaded by normal standalone skc sessions today.",
+};
 
 function resolvePath(args: MCPCommandArgs): ScopedPath {
 	const scope = args.flags.project ? "project" : "user";
@@ -128,6 +141,50 @@ function redactRecord(
 	);
 }
 
+function redactUrl(value: string | undefined): string | undefined {
+	if (!value) return value;
+	try {
+		const url = new URL(value);
+		if (url.username) url.username = REDACTED;
+		if (url.password) url.password = REDACTED;
+		if (url.search) {
+			for (const key of Array.from(url.searchParams.keys())) {
+				url.searchParams.set(key, REDACTED);
+			}
+		}
+		url.hash = "";
+		return url.toString();
+	} catch {
+		return SENSITIVE_KEY_PATTERN.test(value) ? REDACTED : value;
+	}
+}
+
+function redactArgs(args: string[] | undefined): string[] | undefined {
+	if (!args) return undefined;
+	const redacted: string[] = [];
+	let redactNext = false;
+	for (const arg of args) {
+		if (redactNext) {
+			redacted.push(REDACTED);
+			redactNext = false;
+			continue;
+		}
+		const equalsIndex = arg.indexOf("=");
+		if (equalsIndex > 0) {
+			const key = arg.slice(0, equalsIndex);
+			redacted.push(SENSITIVE_KEY_PATTERN.test(key) ? `${key}=${REDACTED}` : arg);
+			continue;
+		}
+		if (arg.startsWith("-") && SENSITIVE_KEY_PATTERN.test(arg)) {
+			redacted.push(arg);
+			redactNext = true;
+			continue;
+		}
+		redacted.push(SENSITIVE_KEY_PATTERN.test(arg) ? REDACTED : arg);
+	}
+	return redacted;
+}
+
 export function redactMCPServerConfig(config: MCPServerConfig): MCPServerConfig {
 	const redacted = { ...config } as MCPServerConfig;
 	if ("env" in redacted) {
@@ -138,11 +195,19 @@ export function redactMCPServerConfig(config: MCPServerConfig): MCPServerConfig
 		const headers = redactRecord(redacted.headers, true);
 		if (headers) redacted.headers = headers;
 	}
+	if ("url" in redacted) {
+		const url = redactUrl(redacted.url);
+		if (url) redacted.url = url;
+	}
+	if ("args" in redacted) {
+		const args = redactArgs(redacted.args);
+		if (args) redacted.args = args;
+	}
 	if (redacted.auth) {
 		redacted.auth = {
 			type: redacted.auth.type,
 			credentialId: redacted.auth.credentialId ? REDACTED : undefined,
-			tokenUrl: redacted.auth.tokenUrl,
+			tokenUrl: redactUrl(redacted.auth.tokenUrl),
 			clientId: redacted.auth.clientId ? REDACTED : undefined,
 			clientSecret: redacted.auth.clientSecret ? REDACTED : undefined,
 		};
@@ -151,7 +216,7 @@ export function redactMCPServerConfig(config: MCPServerConfig): MCPServerConfig
 		redacted.oauth = {
 			clientId: redacted.oauth.clientId ? REDACTED : undefined,
 			clientSecret: redacted.oauth.clientSecret ? REDACTED : undefined,
-			redirectUri: redacted.oauth.redirectUri,
+			redirectUri: redactUrl(redacted.oauth.redirectUri),
 			callbackPort: redacted.oauth.callbackPort,
 			callbackPath: redacted.oauth.callbackPath,
 		};
@@ -159,10 +224,14 @@ export function redactMCPServerConfig(config: MCPServerConfig): MCPServerConfig
 	return redacted;
 }
 
-function collectEntries(config: MCPConfigFile): RedactedServerEntry[] {
+function withRuntimeDisclosure<T extends object>(value: T): T & RuntimeDisclosure {
+	return { ...value, ...STORAGE_ONLY_RUNTIME_DISCLOSURE };
+}
+
+function collectEntries(config: MCPConfigFile): RuntimeRedactedServerEntry[] {
 	return Object.entries(config.mcpServers ?? {})
 		.sort(([a], [b]) => a.localeCompare(b))
-		.map(([name, serverConfig]) => ({ name, config: redactMCPServerConfig(serverConfig) }));
+		.map(([name, serverConfig]) => withRuntimeDisclosure({ name, config: redactMCPServerConfig(serverConfig) }));
 }
 
 function writeJson(value: unknown): void {
@@ -188,37 +257,46 @@ async function runAdd(args: MCPCommandArgs, scoped: ScopedPath): Promise<void> {
 	const result = await upsertMCPServer(scoped.path, args.name, config, { force: args.flags.force });
 	const redacted = redactMCPServerConfig(config);
 	if (args.flags.json) {
-		writeJson({
-			action: "add",
-			status: result.status,
-			name: args.name,
-			scope: scoped.scope,
-			path: scoped.path,
-			config: redacted,
-		});
+		writeJson(
+			withRuntimeDisclosure({
+				action: "add",
+				status: result.status,
+				name: args.name,
+				scope: scoped.scope,
+				path: scoped.path,
+				config: redacted,
+			}),
+		);
 		return;
 	}
 	if (result.status === "skipped") {
 		process.stdout.write(
-			`MCP server "${args.name}" already exists in ${scoped.scope} config. Pass --force to overwrite.\n`,
+			`MCP server "${args.name}" already exists in ${scoped.scope} config. Pass --force to overwrite. ` +
+				"Status: storage-only; normal standalone skc sessions do not load stored MCP registrations today.\n",
 		);
 		return;
 	}
-	process.stdout.write(`MCP server "${args.name}" ${result.status} in ${scoped.scope} config: ${scoped.path}\n`);
+	process.stdout.write(
+		`MCP server "${args.name}" ${result.status} in ${scoped.scope} config: ${scoped.path}\nStatus: storage-only; normal standalone skc sessions do not load stored MCP registrations today.\n`,
+	);
 }
 
 async function runList(args: MCPCommandArgs, scoped: ScopedPath): Promise<void> {
 	const config = await readMCPConfigFile(scoped.path);
 	const entries = collectEntries(config);
 	if (args.flags.json) {
-		writeJson({ action: "list", scope: scoped.scope, path: scoped.path, servers: entries });
+		writeJson(withRuntimeDisclosure({ action: "list", scope: scoped.scope, path: scoped.path, servers: entries }));
 		return;
 	}
 	if (entries.length === 0) {
-		process.stdout.write(`No MCP servers registered in ${scoped.scope} config: ${scoped.path}\n`);
+		process.stdout.write(
+			`No MCP servers registered in ${scoped.scope} config: ${scoped.path}\nStatus: storage-only; normal standalone skc sessions do not load stored MCP registrations today.\n`,
+		);
 		return;
 	}
-	process.stdout.write(`MCP servers in ${scoped.scope} config: ${scoped.path}\n`);
+	process.stdout.write(
+		`MCP servers in ${scoped.scope} config: ${scoped.path}\nStatus: storage-only; normal standalone skc sessions do not load stored MCP registrations today.\n`,
+	);
 	for (const entry of entries) {
 		process.stdout.write(`${renderDetails(entry)}\n`);
 	}
@@ -233,17 +311,21 @@ async function runRemove(args: MCPCommandArgs, scoped: ScopedPath): Promise<void
 	await removeMCPServer(scoped.path, args.name);
 	const entry = { name: args.name, config: redactMCPServerConfig(existing) };
 	if (args.flags.json) {
-		writeJson({
-			action: "remove",
-			status: "removed",
-			name: args.name,
-			scope: scoped.scope,
-			path: scoped.path,
-			removed: entry,
-		});
+		writeJson(
+			withRuntimeDisclosure({
+				action: "remove",
+				status: "removed",
+				name: args.name,
+				scope: scoped.scope,
+				path: scoped.path,
+				removed: entry,
+			}),
+		);
 		return;
 	}
-	process.stdout.write(`Removed MCP server "${args.name}" from ${scoped.scope} config: ${scoped.path}\n`);
+	process.stdout.write(
+		`Removed MCP server "${args.name}" from ${scoped.scope} config: ${scoped.path}\nStatus: storage-only; normal standalone skc sessions do not load stored MCP registrations today.\n`,
+	);
 	process.stdout.write(`${renderDetails(entry)}\n`);
 }