@sayknow-cli/coding-agent 0.3.16 → 0.4.1

package/src/cli/session-picker.ts

@@ -1,13 +1,30 @@
+import * as path from "node:path";
 import { ProcessTerminal, TUI } from "@sayknow-cli/tui";
+import { pathIsWithin } from "@sayknow-cli/utils";
 import { type SessionSelectionResult, SessionSelectorComponent } from "../modes/components/session-selector";
 import { type SessionInfo, SessionManager } from "../session/session-manager";
 import { FileSessionStorage } from "../session/session-storage";
 
+export async function deleteSessionPickerCandidate(sessionPath: string, explicitSessionDir?: string): Promise<void> {
+	if (!explicitSessionDir) {
+		await SessionManager.deleteManagedCandidate(sessionPath);
+		return;
+	}
+	const root = path.resolve(explicitSessionDir);
+	const target = path.resolve(sessionPath);
+	if (!pathIsWithin(root, target))
+		throw new Error("Explicit session deletion escaped the configured session directory.");
+	await new FileSessionStorage().deleteSessionWithArtifacts(target);
+}
+
 /** Show the read-only TUI session picker and return the user's consent intent. */
-export async function selectSession(sessions: SessionInfo[]): Promise<SessionSelectionResult> {
+export async function selectSession(
+	sessions: SessionInfo[],
+	explicitSessionDir?: string,
+): Promise<SessionSelectionResult> {
 	const { promise, resolve } = Promise.withResolvers<SessionSelectionResult>();
 	const ui = new TUI(new ProcessTerminal());
-	const storage = new FileSessionStorage();
+
 	let settled = false;
 	const settle = (selection: SessionSelectionResult): void => {
 		if (settled) return;
@@ -21,7 +38,7 @@ export async function selectSession(sessions: SessionInfo[]): Promise<SessionSel
 		() => settle({ kind: "cancelled" }),
 		() => settle({ kind: "cancelled" }),
 		async session => {
-			await storage.deleteSessionWithArtifacts(session.path);
+			await deleteSessionPickerCandidate(session.path, explicitSessionDir);
 			return true;
 		},
 		SessionManager.inspectSessionTailReadOnly,

package/src/cli/setup-cli.ts

@@ -564,7 +564,7 @@ async function confirmImport(count: number): Promise<boolean> {
  */
 export interface CredentialsSetupDependencies {
 	openStore?: typeof SqliteAuthCredentialStore.open;
-	createAuthStorage?: (store: Awaited<ReturnType<typeof SqliteAuthCredentialStore.open>>) => AuthStorage;
+	createAuthStorage?: (store: SqliteAuthCredentialStore) => AuthStorage;
 	discover?: Parameters<typeof runExternalCredentialAutoImport>[0]["discover"];
 }
 

package/src/cli/worktree-cli.ts

@@ -1,291 +1,13 @@
 /**
- * CLI handler for `skc worktree` — list and clean up agent-managed worktrees.
+ * Tombstone for the removed legacy worktree cleanup API.
  *
- * Layout under `~/.skc/wt/`:
- *
- *   - **PR-checkout worktrees** (`tools/gh.ts`): a regular git worktree dir
- *     containing a `.git` *file* that points back at
- *     `<parent-repo>/.git/worktrees/<name>/`.
- *   - **Task-isolation dirs** (`task/worktree.ts`): a wrapper dir with a
- *     `merged` subdir mounted/cloned by `natives.isoStart`. These are ephemeral
- *     — `ensureIsolation` always `rm -rf`s the base before re-creating it, so
- *     any leftover on disk is a leak from a crashed run.
- *
- * Legacy entries from before the encoding change keep working because git still
- * tracks them by branch name. This command exists to GC them on demand.
+ * The recursive-deletion implementation that previously lived here
+ * (`listWorktrees`/`clearWorktrees`) was deliberately removed and does not
+ * come back through this subpath. This module exists only to fail imports
+ * with actionable migration guidance.
  */
-import * as fs from "node:fs/promises";
-import * as path from "node:path";
-import { getWorktreesDir, isEnoent } from "@sayknow-cli/utils";
-import chalk from "chalk";
-import * as git from "../utils/git";
-
-type WorktreeKind = "pr-checkout" | "task-isolation" | "empty" | "stray";
-
-export interface WorktreeEntry {
-	/** Absolute path to the worktree dir (or stray container) under `~/.skc/wt/`. */
-	path: string;
-	/** Classification of what we found on disk. */
-	kind: WorktreeKind;
-	/** Parent repo root, when this is a registered git worktree. */
-	parentRepo?: string;
-	/** Branch name extracted from the parent's tracking file, when available. */
-	branch?: string;
-	/** When set, the entry is unhealthy and `skc worktree clear` will remove it. */
-	orphanReason?: string;
-}
-
-export interface ListWorktreesOptions {
-	json: boolean;
-}
-
-export interface ClearWorktreesOptions {
-	/** Remove every entry, including live PR-checkout worktrees. */
-	all: boolean;
-	/** Print what would be removed without touching the filesystem. */
-	dryRun: boolean;
-	json: boolean;
-}
-
-export async function listWorktrees(options: ListWorktreesOptions): Promise<void> {
-	const entries = await scanWorktrees();
-	if (options.json) {
-		console.log(JSON.stringify(entries, null, 2));
-		return;
-	}
-	if (entries.length === 0) {
-		console.log(chalk.dim(`No agent-managed worktrees found under ${getWorktreesDir()}.`));
-		return;
-	}
-	let live = 0;
-	let orphaned = 0;
-	for (const entry of entries) {
-		const tag = entry.orphanReason ? chalk.yellow("orphaned") : chalk.green("live    ");
-		const detail = formatEntryDetail(entry);
-		console.log(`${tag}  ${entry.path}`);
-		if (detail) console.log(`          ${chalk.dim(detail)}`);
-		if (entry.orphanReason) orphaned += 1;
-		else live += 1;
-	}
-	console.log(chalk.dim(`\n${live} live · ${orphaned} orphaned · ${entries.length} total`));
-}
-
-export async function clearWorktrees(options: ClearWorktreesOptions): Promise<void> {
-	const entries = await scanWorktrees();
-	const targets = options.all ? entries : entries.filter(entry => entry.orphanReason !== undefined);
-
-	if (targets.length === 0) {
-		if (options.json) {
-			console.log(JSON.stringify({ removed: 0, kept: entries.length }));
-		} else {
-			console.log(chalk.dim(options.all ? "No worktrees to remove." : "No orphaned worktrees to remove."));
-		}
-		return;
-	}
-
-	if (options.dryRun) {
-		if (options.json) {
-			console.log(JSON.stringify({ wouldRemove: targets.map(t => t.path) }, null, 2));
-		} else {
-			for (const target of targets) {
-				console.log(`${chalk.yellow("would remove")}  ${target.path}`);
-			}
-			console.log(chalk.dim(`\n${targets.length} dir${targets.length === 1 ? "" : "s"} would be removed.`));
-		}
-		return;
-	}
-
-	const results: { path: string; ok: boolean; error?: string }[] = [];
-	const parentsToPrune = new Set<string>();
-	for (const target of targets) {
-		try {
-			if (target.kind === "pr-checkout" && target.parentRepo && !target.orphanReason) {
-				// Live worktree: ask git to remove it cleanly. If git refuses (locked,
-				// dirty, etc.), fall back to fs.rm and rely on `worktree prune` to
-				// clean the bookkeeping on the parent side.
-				const removed = await git.worktree.tryRemove(target.parentRepo, target.path, { force: true });
-				if (!removed) {
-					await fs.rm(target.path, { recursive: true, force: true });
-					parentsToPrune.add(target.parentRepo);
-				}
-			} else {
-				await fs.rm(target.path, { recursive: true, force: true });
-				if (target.parentRepo) parentsToPrune.add(target.parentRepo);
-			}
-			results.push({ path: target.path, ok: true });
-		} catch (err) {
-			results.push({ path: target.path, ok: false, error: err instanceof Error ? err.message : String(err) });
-		}
-	}
-
-	// Best-effort: drop stale entries from each affected parent's `.git/worktrees/`.
-	for (const parent of parentsToPrune) {
-		try {
-			await git.worktree.prune(parent);
-		} catch {
-			/* parent repo may already be gone or pruned — ignore */
-		}
-	}
-
-	const succeeded = results.filter(r => r.ok).length;
-	const failed = results.length - succeeded;
-
-	if (options.json) {
-		console.log(JSON.stringify({ removed: succeeded, failed, results }, null, 2));
-		if (failed > 0) process.exitCode = 1;
-		return;
-	}
-
-	for (const result of results) {
-		if (result.ok) {
-			console.log(`${chalk.green("removed")}  ${result.path}`);
-		} else {
-			console.log(`${chalk.red("failed ")}  ${result.path}`);
-			if (result.error) console.log(`          ${chalk.dim(result.error)}`);
-		}
-	}
-	console.log(chalk.dim(`\n${succeeded} removed${failed > 0 ? ` · ${chalk.red(`${failed} failed`)}` : ""}`));
-	if (failed > 0) process.exitCode = 1;
-}
-
-// ───────────────────────────────────────────────────────────────────────────
-// Scanner
-// ───────────────────────────────────────────────────────────────────────────
-
-async function scanWorktrees(): Promise<WorktreeEntry[]> {
-	const root = getWorktreesDir();
-	let topLevel: string[];
-	try {
-		topLevel = await fs.readdir(root);
-	} catch (err) {
-		if (isEnoent(err)) return [];
-		throw err;
-	}
-
-	const entries: WorktreeEntry[] = [];
-	for (const name of topLevel) {
-		const dir = path.join(root, name);
-		const stat = await fs.stat(dir).catch(() => null);
-		if (!stat?.isDirectory()) continue;
-
-		const direct = await classifyDir(dir);
-		if (direct) {
-			entries.push(direct);
-			continue;
-		}
-
-		// Legacy nesting: ~/.skc/wt/<encoded-project>/<branch-or-id>
-		let children: string[];
-		try {
-			children = await fs.readdir(dir);
-		} catch {
-			continue;
-		}
-		let nested = 0;
-		for (const child of children) {
-			const childDir = path.join(dir, child);
-			const childStat = await fs.stat(childDir).catch(() => null);
-			if (!childStat?.isDirectory()) continue;
-			const childClassified = await classifyDir(childDir);
-			if (childClassified) {
-				entries.push(childClassified);
-				nested += 1;
-			}
-		}
-		if (nested === 0) {
-			entries.push({
-				path: dir,
-				kind: children.length === 0 ? "empty" : "stray",
-				orphanReason: children.length === 0 ? "empty directory" : "no recognizable worktree contents",
-			});
-		}
-	}
-	return entries;
-}
-
-async function classifyDir(dir: string): Promise<WorktreeEntry | null> {
-	const gitEntry = path.join(dir, ".git");
-	const gitStat = await fs.stat(gitEntry).catch(() => null);
-	if (gitStat?.isFile()) {
-		return classifyPrCheckout(dir, gitEntry);
-	}
-	const mergedStat = await fs.stat(path.join(dir, "merged")).catch(() => null);
-	if (mergedStat?.isDirectory()) {
-		return {
-			path: dir,
-			kind: "task-isolation",
-			orphanReason: "task-isolation leftover (no live task owns it)",
-		};
-	}
-	return null;
-}
-
-async function classifyPrCheckout(dir: string, gitEntry: string): Promise<WorktreeEntry> {
-	let contents: string;
-	try {
-		contents = await fs.readFile(gitEntry, "utf8");
-	} catch (err) {
-		return {
-			path: dir,
-			kind: "pr-checkout",
-			orphanReason: `cannot read .git file: ${err instanceof Error ? err.message : String(err)}`,
-		};
-	}
-	const match = /^gitdir:\s*(.+?)\s*$/m.exec(contents);
-	const parentGitDir = match?.[1];
-	if (!parentGitDir) {
-		return { path: dir, kind: "pr-checkout", orphanReason: "malformed .git file (no gitdir line)" };
-	}
-	// parentGitDir is `<parent-repo>/.git/worktrees/<name>`; back out the repo root.
-	const parentRepo = path.dirname(path.dirname(path.dirname(parentGitDir)));
-	const branch = await readWorktreeBranch(path.join(parentGitDir, "HEAD"));
-
-	const parentDirStat = await fs.stat(parentGitDir).catch(() => null);
-	if (!parentDirStat?.isDirectory()) {
-		return {
-			path: dir,
-			kind: "pr-checkout",
-			parentRepo,
-			branch,
-			orphanReason: "parent repo no longer tracks this worktree",
-		};
-	}
-	const parentRepoStat = await fs.stat(parentRepo).catch(() => null);
-	if (!parentRepoStat?.isDirectory()) {
-		return {
-			path: dir,
-			kind: "pr-checkout",
-			parentRepo,
-			branch,
-			orphanReason: "parent repo missing",
-		};
-	}
-	return { path: dir, kind: "pr-checkout", parentRepo, branch };
-}
-
-async function readWorktreeBranch(headFile: string): Promise<string | undefined> {
-	try {
-		const head = (await fs.readFile(headFile, "utf8")).trim();
-		const refMatch = /^ref:\s*refs\/heads\/(.+)$/.exec(head);
-		return refMatch?.[1];
-	} catch {
-		return undefined;
-	}
-}
+export {};
 
-function formatEntryDetail(entry: WorktreeEntry): string {
-	const parts: string[] = [];
-	if (entry.kind === "pr-checkout") {
-		const repo = entry.parentRepo ? path.basename(entry.parentRepo) : "unknown repo";
-		const branch = entry.branch ?? "unknown branch";
-		parts.push(`${repo} · ${branch}`);
-	} else if (entry.kind === "task-isolation") {
-		parts.push("task-isolation sandbox");
-	} else if (entry.kind === "empty") {
-		parts.push("legacy project shell");
-	} else {
-		parts.push("unrecognized contents");
-	}
-	if (entry.orphanReason) parts.push(entry.orphanReason);
-	return parts.join(" — ");
-}
+throw new Error(
+	"@sayknow-cli/coding-agent/cli/worktree-cli was deliberately removed: the legacy worktree cleanup API (listWorktrees/clearWorktrees) is gone. Inspect leftover managed worktrees under ~/.skc/wt manually and use `git worktree remove` or `git worktree prune` instead.",
+);

package/src/cli.ts

@@ -9,6 +9,7 @@ import { Args, type CliConfig, Command, type CommandEntry, Flags, run } from "@s
 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";
+import { smokeTestTabWorker } from "./tools/browser/tab-worker-smoke";
 
 if (Bun.semver.order(Bun.version, MIN_BUN_VERSION) < 0) {
 	process.stderr.write(
@@ -40,6 +41,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,19 @@ 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");
+	}
+	const { runChatDaemonInternal } = await import("./sdk/bus/chat-daemon-cli");
+	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 +190,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" }),
@@ -237,16 +253,15 @@ function isSubcommand(first: string | undefined): boolean {
 }
 
 /**
- * Smoke-test entry. Spawns the stats sync worker, pings it, exits.
+ * Smoke-test entry. Spawns the stats sync worker and the browser tab worker, then verifies their protocol.
  *
- * Purpose: catch the silent worker-load regressions that hit compiled
- * binaries (issues #1011 and #1027). Neither `--version` nor
- * `stats --summary` actually spawns a Worker on a fresh install — the
- * sync path early-returns when no session files exist. This probe is the
- * minimal end-to-end test that proves `new Worker(...)` resolves and the
- * bundled worker module evaluates successfully. Wired into
- * `scripts/install-tests/run-ci.sh` so binary / source-link / tarball
- * installs all exercise it on every CI run.
+ * Purpose: catch silent compiled-worker load regressions (issues #1011,
+ * #1027, and #2598). Neither `--version` nor `stats --summary` spawns both
+ * worker entries on a fresh install. This probe proves each bundled worker
+ * module resolves and evaluates; the tab-worker probe also completes its
+ * bootstrap/closed protocol without launching a browser. Wired into
+ * `scripts/install-tests/run-ci.sh` so binary / source-link / tarball installs
+ * exercise it on every CI run.
  */
 async function runSmokeTest(): Promise<void> {
 	const { smokeTestSyncWorker } = await import("@sayknow-cli/stats");
@@ -263,6 +278,7 @@ async function runSmokeTest(): Promise<void> {
 	if (typeof h02ScoreSequenceFuzzy !== "function" || typeof h01FindBestFuzzyMatch !== "function") {
 		throw new Error("smoke-test: native fuzzy exports missing from embedded addon");
 	}
+	await smokeTestTabWorker();
 	process.stdout.write("smoke-test: ok\n");
 }
 
@@ -313,6 +329,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/config.ts

@@ -5,7 +5,7 @@ import { Args, Command, Flags } from "@sayknow-cli/utils/cli";
 import { type ConfigAction, type ConfigCommandArgs, runConfigCommand } from "../cli/config-cli";
 import { initTheme } from "../modes/theme/theme";
 
-const ACTIONS: ConfigAction[] = ["list", "get", "set", "reset", "path", "init-xdg"];
+const ACTIONS: ConfigAction[] = ["list", "get", "set", "reset", "path", "init-xdg", "doctor"];
 
 export default class Config extends Command {
 	static description = "Manage configuration settings";

package/src/commands/daemon.ts

@@ -2,14 +2,22 @@
  * Manage SKC background daemons (status/list/stop/reload).
  */
 import { Args, Command, Flags } from "@sayknow-cli/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 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.";
+		"Manage SKC background daemons and SDK sessions. 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",
@@ -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/gc.ts

@@ -9,9 +9,19 @@ export default class Gc extends Command {
 		prune: Flags.boolean({ description: "Remove stale records (default: report only)", default: false }),
 		force: Flags.boolean({ description: "Alias for --prune (eligible records only)", default: false }),
 		"dry-run": Flags.boolean({ description: "Force report-only mode", default: false }),
+		"repair-session-index": Flags.boolean({
+			description: "Quarantine a corrupt session-index suffix and retain its valid prefix",
+			default: false,
+		}),
 	};
 
-	static examples = ["skc gc", "skc gc --json", "skc gc --prune", "skc gc --prune --json"];
+	static examples = [
+		"skc gc",
+		"skc gc --json",
+		"skc gc --prune",
+		"skc gc --prune --json",
+		"skc gc --repair-session-index --json",
+	];
 
 	async run(): Promise<void> {
 		const result = await runSkcGcCommand(this.argv, process.cwd(), process.env);