@sayknow-cli/coding-agent 0.3.12 → 0.3.15

package/src/cli.ts

@@ -4,9 +4,11 @@
  * CLI entry point — registers all commands explicitly and delegates to the
  * lightweight CLI runner from pi-utils.
  */
+import "@sayknow-cli/utils/postmortem";
 import { Args, type CliConfig, Command, type CommandEntry, Flags, run } from "@sayknow-cli/utils/cli";
 import { APP_NAME, formatBunRuntimeError, MIN_BUN_VERSION, VERSION } from "@sayknow-cli/utils/dirs";
 import { runFixtureReport } from "./cli/fixture-report";
+import { isTmuxOwnerIsolationCliArgv, runTmuxOwnerIsolationCliFromStdin } from "./skc-runtime/tmux-owner-isolation-cli";
 
 if (Bun.semver.order(Bun.version, MIN_BUN_VERSION) < 0) {
 	process.stderr.write(
@@ -80,9 +82,13 @@ async function installRuntimeGlobals(): Promise<void> {
 	const { warnIfMacOSNoFileLimitTooLow } = await import("./cli/nofile-limit");
 	warnIfMacOSNoFileLimitTooLow();
 
-	// Strip macOS malloc-stack-logging env vars before any subprocess is spawned.
-	// Otherwise every child bun process (subagents, plugin installs, ptree spawns,
-	// etc.) prints a `MallocStackLogging: can't turn off …` warning to stderr.
+	// Secondary in-process scrub of the macOS malloc-stack-logging vars. The real
+	// boundary is the darwin re-exec guard at the top of runCli(): Bun snapshots the
+	// spawn-default environment at startup, so deleting these here does NOT clean the
+	// env children inherit by default — it only tidies `process.env` for code that
+	// reads it directly. Kept as belt-and-braces for the rare re-exec-unavailable
+	// fallback; managed spawns already use filterProcessEnv and the native PTY lane
+	// strips them independently.
 	delete process.env.MallocStackLogging;
 	delete process.env.MallocStackLoggingNoCompact;
 }
@@ -260,8 +266,49 @@ async function runSmokeTest(): Promise<void> {
 	process.stdout.write("smoke-test: ok\n");
 }
 
+/** Normalize the sole `skc resume` alias into the value-less launch intent. */
+export function normalizeResumeAlias(argv: readonly string[]): string[] {
+	return argv.length === 1 && argv[0] === "resume" ? ["--resume"] : [...argv];
+}
+
+/** Apply the same default-launch routing used by runCli after root fast paths. */
+export function routeRootArgv(argv: readonly string[]): string[] {
+	const normalizedArgv = normalizeResumeAlias(argv);
+	const first = normalizedArgv[0];
+	return first === "--help" || first === "-h" || first === "--version" || first === "-v" || first === "help"
+		? normalizedArgv
+		: isSubcommand(first)
+			? normalizedArgv
+			: ["launch", ...normalizedArgv];
+}
+
 /** Run the CLI with the given argv (no `process.argv` prefix). */
 export async function runCli(argv: string[]): Promise<void> {
+	// macOS malloc-env launch boundary. Re-exec once with a scrubbed environment
+	// BEFORE any fast path or subprocess spawn, so the startup env snapshot Bun hands
+	// to every child lane (Bun.spawn defaults, node:child_process, native PTY, tmux
+	// owner, plugin installs, subagents) is clean. This runs ahead of the
+	// tmux-owner-isolation and notify-daemon fast paths so those lanes execute inside
+	// the already-scrubbed process too. The cheap inline predicate keeps the common
+	// (uncontaminated / non-darwin) path free of extra module loads; the guard module
+	// (MACOS_MALLOC_ENV_VARS / SKC_MALLOC_ENV_REEXEC) loads only when a re-exec is due.
+	if (
+		process.platform === "darwin" &&
+		process.env.SKC_MALLOC_ENV_REEXEC === undefined &&
+		(process.env.MallocStackLogging !== undefined || process.env.MallocStackLoggingNoCompact !== undefined)
+	) {
+		const { reexecWithScrubbedMallocEnv } = await import("./cli/malloc-env-guard");
+		const code = await reexecWithScrubbedMallocEnv();
+		if (code !== null) {
+			process.exitCode = code;
+			return;
+		}
+		// Re-exec could not be spawned; fall through and run in this process.
+	}
+	if (isTmuxOwnerIsolationCliArgv(argv)) {
+		await runTmuxOwnerIsolationCliFromStdin();
+		return;
+	}
 	if (isNotifyDaemonInternalFastPath(argv)) {
 		await runNotifyDaemonInternalFastPath(argv);
 		return;
@@ -302,13 +349,7 @@ export async function runCli(argv: string[]): Promise<void> {
 	await installRuntimeGlobals();
 	// --help and --version are handled by run() directly, don't rewrite those.
 	// Everything else that isn't a known subcommand routes to "launch".
-	const first = argv[0];
-	const runArgv =
-		first === "--help" || first === "-h" || first === "--version" || first === "-v" || first === "help"
-			? argv
-			: isSubcommand(first)
-				? argv
-				: ["launch", ...argv];
+	const runArgv = routeRootArgv(argv);
 	return run({ bin: APP_NAME, version: VERSION, argv: runArgv, commands, help: showHelp });
 }
 

package/src/commands/daemon.ts

@@ -4,19 +4,32 @@
 import { Args, Command, Flags } from "@sayknow-cli/utils/cli";
 import { type DaemonCliAction, type DaemonCommandArgs, 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";
 
-const ACTIONS: DaemonCliAction[] = ["list", "status", "stop", "reload"];
-
 export default class Daemon extends Command {
-	static description = "Manage SKC background daemons (status, list, stop, reload)";
+	static description =
+		"Manage SKC background daemons. Routine use: `skc daemon status` to check, `skc 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  skc daemon status",
+		"# Reload, spawning a fresh owner if none is running\n  skc daemon restart",
+		"# Full runtime detail and the roots list\n  skc daemon status --verbose",
+		"# Machine-readable output for automation\n  skc daemon status --json",
+		"# Stop, hard-killing an unresponsive owner\n  skc daemon stop --force",
+	];
 
 	static args = {
-		action: Args.string({ description: "Daemon action", required: false, options: ACTIONS }),
+		action: Args.string({
+			description: "Daemon action (status, restart, reload, stop, list)",
+			required: false,
+			options: DAEMON_ACTION_TOKENS as string[],
+		}),
 		kind: Args.string({ description: "Daemon kind(s) to target", required: false, multiple: true }),
 	};
 
 	static flags = {
+		verbose: Flags.boolean({ char: "v", description: "Show runtime detail and the full roots list" }),
 		all: Flags.boolean({ description: "Target all registered daemon kinds" }),
 		json: Flags.boolean({ description: "Emit JSON output" }),
 		force: Flags.boolean({ description: "Allow hard-kill escalation when graceful stop times out" }),
@@ -27,7 +40,7 @@ export default class Daemon extends Command {
 
 	async run(): Promise<void> {
 		const { args, flags } = await this.parse(Daemon);
-		const action = (args.action ?? "status") as DaemonCliAction;
+		const action = (resolveDaemonAction(args.action) ?? "status") as DaemonCliAction;
 		const kinds = (Array.isArray(args.kind) ? args.kind : args.kind ? [args.kind] : []) as DaemonKind[];
 		const flagRec = flags as Record<string, unknown>;
 		const cmd: DaemonCommandArgs = {
@@ -36,6 +49,7 @@ export default class Daemon extends Command {
 			all: Boolean(flags.all),
 			json: Boolean(flags.json),
 			force: Boolean(flags.force),
+			verbose: Boolean(flags.verbose),
 			gracefulTimeoutMs: flagRec["graceful-timeout-ms"] as number | undefined,
 			killTimeoutMs: flagRec["kill-timeout-ms"] as number | undefined,
 			spawnIfStopped: flagRec["spawn-if-stopped"] as boolean | undefined,