@sayknow-cli/coding-agent 0.3.12 → 0.3.15

package/dist/types/tools/subagent.d.ts

@@ -4,13 +4,13 @@ import type { AgentProgress, AgentSource } from "../task/types";
 import type { ToolSession } from "./index";
 declare const subagentSchema: z.ZodObject<{
     action: z.ZodEnum<{
-        await: "await";
-        cancel: "cancel";
-        inspect: "inspect";
-        list: "list";
-        pause: "pause";
         resume: "resume";
+        pause: "pause";
         steer: "steer";
+        list: "list";
+        cancel: "cancel";
+        inspect: "inspect";
+        await: "await";
     }>;
     ids: z.ZodOptional<z.ZodArray<z.ZodString>>;
     id: z.ZodOptional<z.ZodString>;
@@ -19,9 +19,9 @@ declare const subagentSchema: z.ZodObject<{
     timeout_ms: z.ZodOptional<z.ZodNumber>;
     limit: z.ZodOptional<z.ZodNumber>;
     verbosity: z.ZodOptional<z.ZodEnum<{
+        receipt: "receipt";
         full: "full";
         preview: "preview";
-        receipt: "receipt";
     }>>;
 }, z.core.$strip>;
 type SubagentParams = z.infer<typeof subagentSchema>;
@@ -68,13 +68,13 @@ export declare class SubagentTool implements AgentTool<typeof subagentSchema, Su
     readonly description: string;
     readonly parameters: z.ZodObject<{
         action: z.ZodEnum<{
-            await: "await";
-            cancel: "cancel";
-            inspect: "inspect";
-            list: "list";
-            pause: "pause";
             resume: "resume";
+            pause: "pause";
             steer: "steer";
+            list: "list";
+            cancel: "cancel";
+            inspect: "inspect";
+            await: "await";
         }>;
         ids: z.ZodOptional<z.ZodArray<z.ZodString>>;
         id: z.ZodOptional<z.ZodString>;
@@ -83,9 +83,9 @@ export declare class SubagentTool implements AgentTool<typeof subagentSchema, Su
         timeout_ms: z.ZodOptional<z.ZodNumber>;
         limit: z.ZodOptional<z.ZodNumber>;
         verbosity: z.ZodOptional<z.ZodEnum<{
+            receipt: "receipt";
             full: "full";
             preview: "preview";
-            receipt: "receipt";
         }>>;
     }, z.core.$strip>;
     readonly strict = true;

package/dist/types/tools/telegram-send.d.ts

@@ -26,6 +26,13 @@ export declare class TelegramSendTool implements AgentTool<typeof telegramSendSc
     readonly strict = true;
     constructor(session: ToolSession);
     static createIf(session: ToolSession): TelegramSendTool | null;
+    /**
+     * Resolve `requested` against the workspace root and confine it via realpath:
+     * blocks absolute paths outside the project, `..` traversal, and symlinks that
+     * escape the root. Returns the resolved real path of a regular file, or an
+     * error message. This is the egress safety boundary — the model can only send
+     * files that genuinely live inside the session workspace.
+     */
     private resolveContainedFile;
     execute(_toolCallId: string, params: TelegramSendParams, _signal?: AbortSignal, _onUpdate?: AgentToolUpdateCallback<TelegramSendDetails>, _context?: AgentToolContext): Promise<AgentToolResult<TelegramSendDetails>>;
 }

package/dist/types/tools/todo-write.d.ts

@@ -28,13 +28,13 @@ export interface TodoWriteToolDetails {
 declare const todoWriteSchema: z.ZodObject<{
     ops: z.ZodArray<z.ZodObject<{
         op: z.ZodEnum<{
-            append: "append";
-            done: "done";
             drop: "drop";
             init: "init";
-            note: "note";
-            rm: "rm";
             start: "start";
+            done: "done";
+            rm: "rm";
+            append: "append";
+            note: "note";
         }>;
         list: z.ZodOptional<z.ZodArray<z.ZodObject<{
             phase: z.ZodString;
@@ -70,13 +70,13 @@ export declare class TodoWriteTool implements AgentTool<typeof todoWriteSchema,
     readonly parameters: z.ZodObject<{
         ops: z.ZodArray<z.ZodObject<{
             op: z.ZodEnum<{
-                append: "append";
-                done: "done";
                 drop: "drop";
                 init: "init";
-                note: "note";
-                rm: "rm";
                 start: "start";
+                done: "done";
+                rm: "rm";
+                append: "append";
+                note: "note";
             }>;
             list: z.ZodOptional<z.ZodArray<z.ZodObject<{
                 phase: z.ZodString;

package/dist/types/utils/external-editor.d.ts

@@ -8,6 +8,8 @@ export interface OpenInEditorOptions {
     /** Keep the file's trailing newline instead of trimming it from the returned text. */
     trimTrailingNewline?: boolean;
 }
+/** Remove one platform-standard trailing line terminator from editor content. */
+export declare function trimEditorTrailingNewline(text: string): string;
 /**
  * Opens `content` in the user's external editor and returns the edited text.
  * Returns `null` if the editor exits with a non-zero code.

package/dist/types/web/insane/bridge.d.ts

@@ -17,18 +17,18 @@ export declare const INSANE_VENDOR_DIR: string;
 /** Stable note prefixes — tests assert on these without depending on full stderr. */
 export declare const INSANE_NOTES: {
     readonly guardBlocked: (reason: string) => string;
-    readonly vendorMissing: `insane fallback unavailable: vendor engine missing at packages/coding-agent/vendor/insane-search`;
-    readonly noPython: `insane fallback unavailable: python3 not found; install python3 and curl_cffi, then retry with web.insaneFallback=true`;
-    readonly noCurlCffi: `insane fallback unavailable: python3 cannot import curl_cffi; install curl_cffi for Phase 0-2`;
-    readonly noBrowser: `insane fallback unavailable: node/playwright/stealth dependencies missing for Phase 3; install dependencies under packages/coding-agent/vendor/insane-search/engine/templates`;
+    readonly vendorMissing: "insane fallback unavailable: vendor engine missing at packages/coding-agent/vendor/insane-search";
+    readonly noPython: "insane fallback unavailable: python3 not found; install python3 and curl_cffi, then retry with web.insaneFallback=true";
+    readonly noCurlCffi: "insane fallback unavailable: python3 cannot import curl_cffi; install curl_cffi for Phase 0-2";
+    readonly noBrowser: "insane fallback unavailable: node/playwright/stealth dependencies missing for Phase 3; install dependencies under packages/coding-agent/vendor/insane-search/engine/templates";
     readonly timeout: (seconds: number) => string;
-    readonly invalidJson: `insane fallback failed: engine returned invalid JSON`;
-    readonly authRequired: `insane fallback stopped: authentication required`;
+    readonly invalidJson: "insane fallback failed: engine returned invalid JSON";
+    readonly authRequired: "insane fallback stopped: authentication required";
     readonly verdict: (verdict: string) => string;
     readonly untried: (routes: string) => string;
-    readonly mustBrowserMcp: `insane fallback requires browser MCP/manual phase: must_invoke_playwright_mcp=true`;
-    readonly concurrency: `insane fallback skipped: max concurrent engine attempts reached`;
-    readonly emptyContent: `insane fallback failed: engine reported ok but returned no content`;
+    readonly mustBrowserMcp: "insane fallback requires browser MCP/manual phase: must_invoke_playwright_mcp=true";
+    readonly concurrency: "insane fallback skipped: max concurrent engine attempts reached";
+    readonly emptyContent: "insane fallback failed: engine reported ok but returned no content";
 };
 /** Raw JSON envelope produced by `python3 -m engine --json`. */
 export interface InsaneFetchResultRaw {

package/dist/types/web/search/index.d.ts

@@ -16,8 +16,8 @@ export declare const webSearchSchema: z.ZodObject<{
     query: z.ZodString;
     recency: z.ZodOptional<z.ZodEnum<{
         day: "day";
-        month: "month";
         week: "week";
+        month: "month";
         year: "year";
     }>>;
     limit: z.ZodOptional<z.ZodNumber>;
@@ -25,9 +25,9 @@ export declare const webSearchSchema: z.ZodObject<{
     temperature: z.ZodOptional<z.ZodNumber>;
     num_search_results: z.ZodOptional<z.ZodNumber>;
     xai_search_mode: z.ZodOptional<z.ZodEnum<{
+        x: "x";
         web: "web";
         web_and_x: "web_and_x";
-        x: "x";
     }>>;
     allowed_domains: z.ZodOptional<z.ZodArray<z.ZodString>>;
     excluded_domains: z.ZodOptional<z.ZodArray<z.ZodString>>;
@@ -79,8 +79,8 @@ export declare class WebSearchTool implements AgentTool<typeof webSearchSchema,
         query: z.ZodString;
         recency: z.ZodOptional<z.ZodEnum<{
             day: "day";
-            month: "month";
             week: "week";
+            month: "month";
             year: "year";
         }>>;
         limit: z.ZodOptional<z.ZodNumber>;
@@ -88,9 +88,9 @@ export declare class WebSearchTool implements AgentTool<typeof webSearchSchema,
         temperature: z.ZodOptional<z.ZodNumber>;
         num_search_results: z.ZodOptional<z.ZodNumber>;
         xai_search_mode: z.ZodOptional<z.ZodEnum<{
+            x: "x";
             web: "web";
             web_and_x: "web_and_x";
-            x: "x";
         }>>;
         allowed_domains: z.ZodOptional<z.ZodArray<z.ZodString>>;
         excluded_domains: z.ZodOptional<z.ZodArray<z.ZodString>>;

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@sayknow-cli/coding-agent",
-	"version": "0.3.12",
+	"version": "0.3.15",
 	"description": "Sayknow-CLI CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://sayknow-cli.com",
 	"author": "jaybeyond",
@@ -49,15 +49,15 @@
 		"verify:insane-vendor": "bun scripts/verify-insane-vendor.ts"
 	},
 	"dependencies": {
-		"@agentclientprotocol/sdk": "0.21.0",
+		"@agentclientprotocol/sdk": "1.2.1",
 		"@babel/parser": "^7.29.3",
 		"@mozilla/readability": "^0.6.0",
-		"@sayknow-cli/stats": "0.3.12",
-		"@sayknow-cli/agent-core": "0.3.12",
-		"@sayknow-cli/ai": "0.3.12",
-		"@sayknow-cli/natives": "0.3.12",
-		"@sayknow-cli/tui": "0.3.12",
-		"@sayknow-cli/utils": "0.3.12",
+		"@sayknow-cli/stats": "0.3.15",
+		"@sayknow-cli/agent-core": "0.3.15",
+		"@sayknow-cli/ai": "0.3.15",
+		"@sayknow-cli/natives": "0.3.15",
+		"@sayknow-cli/tui": "0.3.15",
+		"@sayknow-cli/utils": "0.3.15",
 		"@puppeteer/browsers": "^2.13.0",
 		"@types/turndown": "5.0.6",
 		"@xterm/headless": "^6.0.0",

package/scripts/g004-tmux-smoke.ts

@@ -1,100 +1,260 @@
-// G004 real-tmux smoke: exercises forceCloseSkcTmuxSession against LIVE tmux
-// sessions (tmux 3.6a). Proves the wrapper hard-kills SKC-managed live panes
-// (where remove refuses), refuses non-SKC sessions, and enforces session-id
-// matching. Produces durable evidence; not part of the unit suite.
+// G004 real-tmux smoke: exercises forceCloseSkcTmuxSession refusal boundaries
+// against live tmux sessions. Generation-bound successful TERM/verdict/cleanup is
+// covered by the issue evidence harness; this smoke proves incomplete and non-SKC
+// live owners are never hard-killed.
 import assert from "node:assert";
+import { randomUUID } from "node:crypto";
+import { chmodSync, existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
 
 import {
 	buildSkcTmuxExactOptionTarget,
+	buildSkcTmuxExactSessionTarget,
 	buildSkcTmuxProfileCommands,
 	resolveSkcTmuxCommand,
 } from "../src/skc-runtime/tmux-common";
 import { forceCloseSkcTmuxSession, removeSkcTmuxSession, statusSkcTmuxSession } from "../src/skc-runtime/tmux-sessions";
 
-const tmux = resolveSkcTmuxCommand(process.env);
+const runId = randomUUID().slice(0, 8);
+const suffix = `${process.pid}-${runId}`;
+const privateTmpdir = mkdtempSync(path.join(tmpdir(), "g4-"));
+chmodSync(privateTmpdir, 0o700);
+const socket = `g4-${runId}`;
+const wrapper = path.join(privateTmpdir, "tmux-private.sh");
+const scopeUnit = `skc-g004-${suffix}.scope`;
+const tmuxBootstrapEnv: NodeJS.ProcessEnv = {
+	...process.env,
+	TMUX: "",
+	TMUX_PANE: "",
+	TMUX_TMPDIR: privateTmpdir,
+};
+const tmuxBinary = resolveSkcTmuxCommand(tmuxBootstrapEnv);
+const privateEnv: NodeJS.ProcessEnv = {
+	...tmuxBootstrapEnv,
+	SKC_TMUX_COMMAND: wrapper,
+};
+let scopeRunner: Bun.Subprocess<"ignore", "ignore", "pipe"> | null = null;
 
-function sh(args: string[]): { code: number; err: string } {
-	const r = Bun.spawnSync([tmux, ...args], { stdout: "pipe", stderr: "pipe" });
-	return { code: r.exitCode, err: r.stderr.toString().trim() };
+function shellQuote(value: string): string {
+	return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+
+function bounded(value: string): string {
+	return value.trim().slice(0, 512) || "no diagnostic";
+}
+
+function sh(args: string[]): { code: number; out: string; err: string } {
+	try {
+		const r = Bun.spawnSync([wrapper, ...args], { env: privateEnv, stdout: "pipe", stderr: "pipe" });
+		return { code: r.exitCode, out: r.stdout.toString().trim(), err: r.stderr.toString().trim() };
+	} catch (error) {
+		return { code: -1, out: "", err: bounded(String(error)) };
+	}
 }
 
 function makeRawSession(name: string): void {
 	const r = sh(["new-session", "-d", "-s", name, "sleep 600"]);
-	if (r.code !== 0) throw new Error(`failed to create tmux session ${name}: ${r.err}`);
+	if (r.code !== 0) throw new Error(`failed to create private tmux session ${name}: ${bounded(r.err)}`);
 }
 
 function tagAsSkc(name: string, sessionId?: string): void {
-	const target = buildSkcTmuxExactOptionTarget(name);
-	for (const cmd of buildSkcTmuxProfileCommands(target, process.env, { sessionId })) {
+	const target = buildSkcTmuxExactOptionTarget(name, { env: privateEnv });
+	for (const cmd of buildSkcTmuxProfileCommands(target, privateEnv, { sessionId })) {
 		const r = sh(cmd.args);
-		if (r.code !== 0) throw new Error(`failed to tag ${name} (${cmd.description}): ${r.err}`);
+		if (r.code !== 0) throw new Error(`failed to tag ${name} (${cmd.description}): ${bounded(r.err)}`);
 	}
 }
 
 function exists(name: string): boolean {
-	return sh(["has-session", "-t", `=${name}`]).code === 0;
+	return sh(["has-session", "-t", buildSkcTmuxExactSessionTarget(name, { env: privateEnv })]).code === 0;
+}
+
+function isPrivateSessionAbsent(name: string): boolean {
+	const result = sh(["has-session", "-t", buildSkcTmuxExactSessionTarget(name, { env: privateEnv })]);
+	return result.code !== 0 && /(?:no server running|can't find session|no sessions)/i.test(result.err);
 }
 
-function killQuiet(name: string): void {
-	sh(["kill-session", "-t", `=${name}`]);
+function privateServerPid(session: string): number | null {
+	const result = sh([
+		"display-message",
+		"-p",
+		"-t",
+		buildSkcTmuxExactOptionTarget(session, { env: privateEnv }),
+		"#{pid}",
+	]);
+	const pid = Number.parseInt(result.out, 10);
+	return result.code === 0 && Number.isSafeInteger(pid) && pid > 0 ? pid : null;
+}
+
+function scopeIsActive(): boolean {
+	return (
+		Bun.spawnSync(["systemctl", "--user", "is-active", "--quiet", scopeUnit], { stdout: "ignore", stderr: "ignore" })
+			.exitCode === 0
+	);
+}
+
+function serverIsProvenInScope(session: string): boolean {
+	const pid = privateServerPid(session);
+	if (pid == null) return false;
+	const controlGroup = Bun.spawnSync(
+		["systemctl", "--user", "show", scopeUnit, "--property=ControlGroup", "--value"],
+		{ stdout: "pipe", stderr: "ignore" },
+	);
+	const group = controlGroup.stdout.toString().trim();
+	if (controlGroup.exitCode !== 0 || !group.startsWith("/")) return false;
+	try {
+		return readFileSync(`/proc/${pid}/cgroup`, "utf8")
+			.split("\n")
+			.some(line => line.endsWith(group));
+	} catch {
+		return false;
+	}
+}
+
+async function makeFirstPrivateSession(name: string): Promise<void> {
+	if (process.platform !== "linux") {
+		makeRawSession(name);
+		return;
+	}
+	try {
+		scopeRunner = Bun.spawn(
+			[
+				"systemd-run",
+				"--user",
+				"--quiet",
+				"--collect",
+				`--setenv=TMUX_TMPDIR=${privateTmpdir}`,
+				"--scope",
+				`--unit=${scopeUnit}`,
+				wrapper,
+				"new-session",
+				"-d",
+				"-s",
+				name,
+				"sleep 600",
+			],
+			{ env: privateEnv, stdout: "ignore", stderr: "pipe" },
+		);
+	} catch (error) {
+		throw new Error(`failed to provision private user scope ${scopeUnit}: ${bounded(String(error))}`);
+	}
+	for (let attempt = 0; attempt < 50; attempt += 1) {
+		if (scopeIsActive() && exists(name) && serverIsProvenInScope(name)) return;
+		await Bun.sleep(50);
+	}
+	throw new Error(`failed to provision a proven private user scope ${scopeUnit}`);
+}
+
+async function cleanupOwnedResources(names: string[]): Promise<void> {
+	const failures: string[] = [];
+	for (const name of names) {
+		const result = sh(["kill-session", "-t", buildSkcTmuxExactSessionTarget(name, { env: privateEnv })]);
+		if (result.code !== 0 && !isPrivateSessionAbsent(name)) failures.push(`session ${name}: ${bounded(result.err)}`);
+	}
+	const server = sh(["kill-server"]);
+	if (server.code !== 0) {
+		const probe = sh(["list-sessions"]);
+		if (!/(?:no server running|failed to connect to server|error connecting to)/i.test(probe.err))
+			failures.push(`server: ${bounded(server.err)}`);
+	}
+	if (process.platform === "linux") {
+		const stop = Bun.spawnSync(["systemctl", "--user", "stop", scopeUnit], { stdout: "pipe", stderr: "pipe" });
+		const state = Bun.spawnSync(
+			["systemctl", "--user", "show", scopeUnit, "--property=ActiveState", "--property=LoadState", "--value"],
+			{ stdout: "pipe", stderr: "pipe" },
+		);
+		const states = state.stdout.toString().trim().split("\n");
+		const scopeAbsent = state.exitCode === 0 && (states.includes("inactive") || states.includes("not-found"));
+		if (stop.exitCode !== 0 && !scopeAbsent) failures.push(`scope stop: ${bounded(stop.stderr.toString())}`);
+		if (!scopeAbsent)
+			failures.push(`scope remains present: ${bounded(state.stderr.toString() || state.stdout.toString())}`);
+		if (scopeRunner != null) {
+			const exited = await Promise.race([scopeRunner.exited.then(() => true), Bun.sleep(3_000).then(() => false)]);
+			if (!exited) {
+				try {
+					scopeRunner.kill();
+				} catch (error) {
+					failures.push(`scope runner: ${bounded(String(error))}`);
+				}
+				const killed = await Promise.race([
+					scopeRunner.exited.then(() => true),
+					Bun.sleep(1_000).then(() => false),
+				]);
+				if (!killed) failures.push("scope runner did not exit after scope cleanup");
+			}
+		}
+	}
+	try {
+		rmSync(privateTmpdir, { recursive: true });
+	} catch (error) {
+		if (existsSync(privateTmpdir)) failures.push(`temporary directory: ${bounded(String(error))}`);
+	}
+	if (existsSync(privateTmpdir)) failures.push("temporary directory remains present");
+	if (failures.length > 0) throw new Error(`g004 cleanup incomplete: ${failures.join("; ")}`);
 }
 
-const suffix = `${process.pid}-${Date.now()}`;
 const live = `skc_g004live_${suffix}`;
 const raw = `g004raw_${suffix}`;
 const mism = `skc_g004mism_${suffix}`;
-const cleanup: string[] = [live, raw, mism];
+const cleanup = [live, raw, mism];
 
 try {
-	// 1. SKC-managed LIVE session: remove refuses, force-close hard-kills.
-	makeRawSession(live);
+	writeFileSync(wrapper, `#!/bin/sh\nexec ${shellQuote(tmuxBinary)} -L ${shellQuote(socket)} "$@"\n`, { mode: 0o700 });
+	chmodSync(wrapper, 0o700);
+
+	// 1. Incompletely tagged LIVE session: remove refuses and force-close fails closed.
+	await makeFirstPrivateSession(live);
 	tagAsSkc(live, "sess-g004");
-	const status = statusSkcTmuxSession(live);
+	const status = statusSkcTmuxSession(live, privateEnv);
 	assert.equal(status.profile, "1", "session must be recognized as SKC-managed");
 	assert.ok(status.panePids.length > 0, "session must have a live pane (sleep)");
-	console.log(`[g004] live SKC session up: ${live} panePids=${status.panePids.length}`);
+	process.stdout.write(`[g004] incomplete SKC session up: ${live} panePids=${status.panePids.length}\n`);
 
 	let removeRefused = false;
 	try {
-		removeSkcTmuxSession(live);
+		removeSkcTmuxSession(live, privateEnv);
 	} catch (e) {
 		removeRefused = /skc_tmux_session_live/.test(String(e));
 	}
 	assert.ok(removeRefused, "removeSkcTmuxSession must REFUSE a live pane");
-	console.log("[g004] remove refused live session (expected)");
 
-	const closed = forceCloseSkcTmuxSession(live, process.env, "sess-g004");
-	assert.equal(closed.name, live);
-	assert.ok(!exists(live), "force-close must hard-kill the live SKC session");
-	console.log("[g004] force-close hard-killed the live SKC session (id-matched)");
+	let ownerUnverifiable = false;
+	try {
+		await forceCloseSkcTmuxSession(live, privateEnv, "sess-g004");
+	} catch (e) {
+		ownerUnverifiable = /skc_tmux_owner_unverifiable/.test(String(e));
+	}
+	assert.ok(ownerUnverifiable, "force-close must refuse incomplete owner provenance");
+	assert.ok(exists(live), "incompletely tagged session must be left untouched");
+	process.stdout.write("[g004] force-close refused incomplete owner provenance (expected)\n");
 
 	// 2. Non-SKC (untagged) session: force-close must refuse.
 	makeRawSession(raw);
 	let notManaged = false;
 	try {
-		forceCloseSkcTmuxSession(raw, process.env);
+		await forceCloseSkcTmuxSession(raw, privateEnv);
 	} catch (e) {
-		notManaged = /skc_tmux_session_(not_managed|not_found)/.test(String(e));
+		notManaged = /skc_tmux_session_(not_managed|not_found|untagged)/.test(String(e));
 	}
 	assert.ok(notManaged, "force-close must refuse a non-SKC tmux session");
 	assert.ok(exists(raw), "non-SKC session must be left untouched");
-	killQuiet(raw);
-	console.log("[g004] force-close refused + preserved non-SKC session (expected)");
+	process.stdout.write("[g004] force-close refused + preserved non-SKC session (expected)\n");
 
 	// 3. SKC session with a MISMATCHED expected session id: must refuse.
 	makeRawSession(mism);
 	tagAsSkc(mism, "sess-real");
 	let idMismatch = false;
 	try {
-		forceCloseSkcTmuxSession(mism, process.env, "sess-WRONG");
+		await forceCloseSkcTmuxSession(mism, privateEnv, "sess-WRONG");
 	} catch (e) {
 		idMismatch = /skc_tmux_session_id_mismatch/.test(String(e));
 	}
 	assert.ok(idMismatch, "force-close must refuse on session-id mismatch");
 	assert.ok(exists(mism), "mismatched session must be left untouched");
-	console.log("[g004] force-close refused on session-id mismatch (expected)");
-
-	console.log("[g004] PASS: forceCloseSkcTmuxSession verified against live tmux");
+	process.stdout.write("[g004] force-close refused on session-id mismatch (expected)\n");
 } finally {
-	for (const name of cleanup) killQuiet(name);
+	await cleanupOwnedResources(cleanup);
 }
+
+process.stdout.write("[g004] PASS: forceCloseSkcTmuxSession refusal boundaries verified against live tmux\n");

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;
 }