@sayknow-cli/coding-agent 0.3.12 → 0.3.13

package/src/cli/notify-cli.ts

@@ -7,9 +7,19 @@ import { createInterface } from "node:readline/promises";
 import { APP_NAME } from "@sayknow-cli/utils/dirs";
 import chalk from "chalk";
 import type { Settings } from "../config/settings";
-import { getNotificationConfig, maskToken } from "../notifications/config";
-
-export type NotifyAction = "setup" | "status" | "daemon-internal";
+import { maskToken } from "../notifications/config";
+import {
+	buildNotificationStatusReport,
+	checkNotificationHealth,
+	formatNotificationHealthReport,
+	formatNotificationRecoveryReport,
+	formatNotificationStatusReport,
+	formatNotificationTestResult,
+	recoverNotifications,
+	sendNotificationTest,
+} from "../notifications/notification-service";
+
+export type NotifyAction = "setup" | "status" | "health" | "test" | "recovery" | "daemon-internal";
 
 export interface NotifyCommandArgs {
 	action: NotifyAction;
@@ -18,6 +28,8 @@ export interface NotifyCommandArgs {
 	token?: string;
 	chatId?: string;
 	redact?: boolean;
+	probe?: boolean;
+	message?: string;
 }
 
 export interface NotifyCommandDeps {
@@ -93,6 +105,19 @@ export function parseNotifyArgs(args: string[]): NotifyCommandArgs | undefined {
 			redact: rest.includes("--redact"),
 		};
 	}
+	if (action === "health" || action === "test" || action === "recovery") {
+		const rest = args.slice(2);
+		const flag = (name: string): string | undefined => {
+			const i = rest.indexOf(name);
+			return i >= 0 ? rest[i + 1] : undefined;
+		};
+		return {
+			action,
+			rawArgs: rest,
+			probe: rest.includes("--probe"),
+			message: flag("--message"),
+		};
+	}
 	if (action === "daemon-internal") {
 		return {
 			action,
@@ -117,6 +142,15 @@ export async function runNotifyCommand(cmd: NotifyCommandArgs, deps: NotifyComma
 		case "status":
 			await runStatus(deps);
 			return;
+		case "health":
+			await runHealth(deps, cmd);
+			return;
+		case "test":
+			await runTest(deps, cmd);
+			return;
+		case "recovery":
+			await runRecovery(deps);
+			return;
 		case "daemon-internal": {
 			const m = await import("../notifications/telegram-daemon-cli");
 			if (cmd.smoke) {
@@ -411,20 +445,42 @@ async function verifyThreadedMode(
 
 async function runStatus(deps: NotifyCommandDeps): Promise<void> {
 	const settings = await getSettings(deps);
-	const cfg = getNotificationConfig(settings);
+	const report = buildNotificationStatusReport(settings);
 	process.stdout.write(
-		`${chalk.bold("Notifications")}\n` +
-			`  enabled: ${cfg.enabled}\n` +
-			`  telegram.botToken: ${maskToken(cfg.botToken)}\n` +
-			`  telegram.chatId: ${cfg.chatId ?? "(unset)"}\n` +
-			`  discord.botToken: ${maskToken(cfg.discord.botToken)}\n` +
-			`  discord.channelId: ${cfg.discord.channelId ?? "(unset)"}\n` +
-			`  slack.botToken: ${maskToken(cfg.slack.botToken)}\n` +
-			`  slack.channelId: ${cfg.slack.channelId ?? "(unset)"}\n` +
-			`  redact: ${cfg.redact}\n`,
+		`${chalk.bold("Notifications")}\n${formatNotificationStatusReport(report).split("\n").slice(1).join("\n")}\n`,
 	);
 }
 
+async function runHealth(deps: NotifyCommandDeps, cmd: NotifyCommandArgs): Promise<void> {
+	const settings = await getSettings(deps);
+	const report = await checkNotificationHealth({
+		settings,
+		probe: cmd.probe,
+		deps: { fetchImpl: deps.fetchImpl, apiBase: deps.apiBase },
+	});
+	process.stdout.write(`${formatNotificationHealthReport(report)}\n`);
+	if (report.overall === "error" && deps.setExitCode) deps.setExitCode(1);
+	else if (report.overall === "error") process.exitCode = 1;
+}
+
+async function runTest(deps: NotifyCommandDeps, cmd: NotifyCommandArgs): Promise<void> {
+	const settings = await getSettings(deps);
+	const result = await sendNotificationTest({
+		settings,
+		text: cmd.message,
+		deps: { fetchImpl: deps.fetchImpl, apiBase: deps.apiBase },
+	});
+	process.stdout.write(`${formatNotificationTestResult(result)}\n`);
+	if (!result.ok && deps.setExitCode) deps.setExitCode(1);
+	else if (!result.ok) process.exitCode = 1;
+}
+
+async function runRecovery(deps: NotifyCommandDeps): Promise<void> {
+	const settings = await getSettings(deps);
+	const report = await recoverNotifications({ settings });
+	process.stdout.write(`${formatNotificationRecoveryReport(report)}\n`);
+}
+
 async function waitForPrivateChat(
 	fetchImpl: typeof fetch,
 	apiBase: string,
@@ -514,15 +570,23 @@ ${chalk.bold("Usage:")}
   ${APP_NAME} notify setup
   ${APP_NAME} notify setup --token <botToken> --chat-id <chatId> [--redact]
   ${APP_NAME} notify status
+  ${APP_NAME} notify health [--probe]
+  ${APP_NAME} notify test [--message <text>]
+  ${APP_NAME} notify recovery
 
 ${chalk.bold("Subcommands:")}
   setup     Pair a Telegram bot token with a private chat and verify Threaded Mode capability
   status    Show notification configuration without secrets
+  health    Report config, daemon-ownership and endpoint health (--probe adds a Telegram reachability check)
+  test      Send a one-off test notification through the configured Telegram adapter
+  recovery  Clear dead-owner daemon locks and stale per-session endpoint files (never touches a live owner)
 
 ${chalk.bold("Examples:")}
   ${APP_NAME} notify setup
-  ${APP_NAME} notify setup --token <botToken> --chat-id <chatId> [--redact]
   ${APP_NAME} notify status
+  ${APP_NAME} notify health --probe
+  ${APP_NAME} notify test --message "hello from skc"
+  ${APP_NAME} notify recovery
 
 ${chalk.bold("Threaded Mode:")}
   SKC uses Telegram private-chat topics for per-session threads. Setup verifies the bot

package/src/cli/session-picker.ts

@@ -1,49 +1,32 @@
 import { ProcessTerminal, TUI } from "@sayknow-cli/tui";
-import { SessionSelectorComponent } from "../modes/components/session-selector";
-import type { SessionInfo } from "../session/session-manager";
+import { type SessionSelectionResult, SessionSelectorComponent } from "../modes/components/session-selector";
+import { type SessionInfo, SessionManager } from "../session/session-manager";
 import { FileSessionStorage } from "../session/session-storage";
 
-/** Show TUI session selector and return selected session path or null if cancelled */
-export async function selectSession(sessions: SessionInfo[]): Promise<string | null> {
-	const { promise, resolve } = Promise.withResolvers<string | null>();
+/** Show the read-only TUI session picker and return the user's consent intent. */
+export async function selectSession(sessions: SessionInfo[]): Promise<SessionSelectionResult> {
+	const { promise, resolve } = Promise.withResolvers<SessionSelectionResult>();
 	const ui = new TUI(new ProcessTerminal());
-	let resolved = false;
 	const storage = new FileSessionStorage();
-
-	const showSelector = () => {
-		const selector = new SessionSelectorComponent(
-			sessions,
-			(path: string) => {
-				if (!resolved) {
-					resolved = true;
-					ui.stop();
-					resolve(path);
-				}
-			},
-			() => {
-				if (!resolved) {
-					resolved = true;
-					ui.stop();
-					resolve(null);
-				}
-			},
-			() => {
-				if (!resolved) {
-					resolved = true;
-					ui.stop();
-					process.exit(0);
-				}
-			},
-			async (session: SessionInfo) => {
-				// Delete handler - SessionList will show confirmation internally
-				await storage.deleteSessionWithArtifacts(session.path);
-				return true;
-			},
-		);
-		return selector;
+	let settled = false;
+	const settle = (selection: SessionSelectionResult): void => {
+		if (settled) return;
+		settled = true;
+		ui.stop();
+		resolve(selection);
 	};
-
-	const selector = showSelector();
+	const selector = new SessionSelectorComponent(
+		sessions,
+		() => {},
+		() => settle({ kind: "cancelled" }),
+		() => settle({ kind: "cancelled" }),
+		async session => {
+			await storage.deleteSessionWithArtifacts(session.path);
+			return true;
+		},
+		SessionManager.inspectSessionTailReadOnly,
+		settle,
+	);
 	selector.setOnRequestRender(() => ui.requestRender());
 	ui.addChild(selector);
 	ui.setFocus(selector);

package/src/cli/update-cli.ts

@@ -45,7 +45,6 @@ export interface PackageManagerUpdateOptions {
 	expectedVersion: string;
 	runInstall: PackageManagerUpdateRunner;
 	verifyInstalledRuntime: (expectedVersion: string) => Promise<InstalledVersionVerification>;
-	printVerificationResult?: (expectedVersion: string) => Promise<void>;
 	printRecoveredVerification?: (expectedVersion: string) => void;
 }
 
@@ -122,8 +121,11 @@ function isPathInDirectory(filePath: string, directoryPath: string): boolean {
 	return isPathInDirectoryLexical(resolvedFile, dirReal);
 }
 
-type PackageManagerTarget = { manager: "npm"; packageName: string };
-type UpdateTarget = { method: "bun" } | { method: "npm"; packageName: string } | { method: "binary"; path: string };
+export type PackageManagerTarget = { manager: "npm"; packageName: string };
+export type UpdateTarget =
+	| { method: "bun" }
+	| { method: "npm"; packageName: string }
+	| { method: "binary"; path: string };
 
 type PathPlatform = NodeJS.Platform;
 type PackageExists = (packageName: string, packageRoot: string) => boolean;
@@ -423,19 +425,6 @@ export function formatVerificationFailureForTest(
 	return formatVerificationFailure(result, expectedVersion);
 }
 
-/**
- * Print post-update verification result.
- */
-async function printVerification(expectedVersion: string): Promise<void> {
-	const result = await verifyInstalledRuntime(expectedVersion);
-	if (result.ok) {
-		printSuccessfulVerification(expectedVersion);
-		return;
-	}
-	console.log(chalk.yellow(`\nWarning: ${formatVerificationFailure(result, expectedVersion)}`));
-	console.log(chalk.yellow(formatManualUpdateInstructions()));
-}
-
 async function unlinkIfExists(filePath: string): Promise<void> {
 	try {
 		await fs.promises.unlink(filePath);
@@ -499,6 +488,14 @@ function formatPackageManagerInstallFailure(
 	return `${managerName} install failed with exit code ${result.exitCode ?? "unknown"}${outputSuffix}. ${formatVerificationFailure(verification, expectedVersion)}`;
 }
 
+function formatPackageManagerVerificationFailure(
+	managerName: string,
+	verification: InstalledVersionVerification,
+	expectedVersion: string,
+): string {
+	return `${managerName} install exited successfully, but the selected ${APP_NAME} runtime failed verification: ${formatVerificationFailure(verification, expectedVersion)}`;
+}
+
 export async function runPackageManagerUpdateForTest(
 	options: PackageManagerUpdateOptions,
 ): Promise<InstalledVersionVerification> {
@@ -508,8 +505,14 @@ export async function runPackageManagerUpdateForTest(
 async function updateViaPackageManager(options: PackageManagerUpdateOptions): Promise<InstalledVersionVerification> {
 	const result = await options.runInstall(options.expectedVersion);
 	if (result.exitCode === 0) {
-		await (options.printVerificationResult ?? printVerification)(options.expectedVersion);
-		return await options.verifyInstalledRuntime(options.expectedVersion);
+		const verification = await options.verifyInstalledRuntime(options.expectedVersion);
+		if (!verification.ok) {
+			throw new Error(
+				formatPackageManagerVerificationFailure(options.managerName, verification, options.expectedVersion),
+			);
+		}
+		printSuccessfulVerification(options.expectedVersion);
+		return verification;
 	}
 
 	const verification = await options.verifyInstalledRuntime(options.expectedVersion);
@@ -661,16 +664,42 @@ async function updateViaBinaryAt(targetPath: string, expectedVersion: string): P
 /**
  * Run the update command.
  */
-export async function runUpdateCommand(opts: { force: boolean; check: boolean }): Promise<void> {
+export interface UpdateCommandDependencies {
+	getLatestRelease?: () => Promise<ReleaseInfo>;
+	resolveUpdateTarget?: () => Promise<UpdateTarget>;
+	performUpdate?: (target: UpdateTarget, expectedVersion: string) => Promise<void>;
+	refreshInstalledDefaultSkills?: () => Promise<void>;
+	exit?: (code: number) => never;
+}
+
+async function performUpdate(target: UpdateTarget, expectedVersion: string): Promise<void> {
+	if (target.method === "bun") {
+		await updateViaBun(expectedVersion);
+	} else if (target.method === "npm") {
+		await updateViaNpm(target.packageName, expectedVersion);
+	} else {
+		await updateViaBinaryAt(target.path, expectedVersion);
+	}
+}
+
+export async function runUpdateCommand(
+	opts: { force: boolean; check: boolean },
+	deps: UpdateCommandDependencies = {},
+): Promise<void> {
+	const lookupRelease = deps.getLatestRelease ?? getLatestRelease;
+	const resolveTarget = deps.resolveUpdateTarget ?? resolveUpdateTarget;
+	const update = deps.performUpdate ?? performUpdate;
+	const refreshDefaults = deps.refreshInstalledDefaultSkills ?? refreshInstalledDefaultSkills;
+	const exit = deps.exit ?? process.exit;
+
 	console.log(chalk.dim(`Current version: ${VERSION}`));
 
-	// Check for updates
 	let release: ReleaseInfo;
 	try {
-		release = await getLatestRelease();
+		release = await lookupRelease();
 	} catch (err) {
 		console.error(chalk.red(`Failed to check for updates: ${err}`));
-		process.exit(1);
+		return exit(1);
 	}
 
 	const comparison = compareVersions(release.version, VERSION);
@@ -686,27 +715,17 @@ export async function runUpdateCommand(opts: { force: boolean; check: boolean })
 		console.log(chalk.yellow(`Forcing reinstall of ${release.version}`));
 	}
 
-	if (opts.check) {
-		// Just check, don't install
-		return;
-	}
+	if (opts.check) return;
 
-	// Choose update method based on the prioritized skc binary in PATH
 	try {
-		const target = await resolveUpdateTarget();
-		if (target.method === "bun") {
-			await updateViaBun(release.version);
-		} else if (target.method === "npm") {
-			await updateViaNpm(target.packageName, release.version);
-		} else {
-			await updateViaBinaryAt(target.path, release.version);
-		}
+		const target = await resolveTarget();
+		await update(target, release.version);
 	} catch (err) {
 		console.error(chalk.red(`Update failed: ${err}`));
-		process.exit(1);
+		return exit(1);
 	}
 
-	await refreshInstalledDefaultSkills();
+	await refreshDefaults();
 }
 
 /**

package/src/cli.ts

@@ -7,6 +7,7 @@
 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 +81,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 +265,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 +348,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,