@gajae-code/coding-agent 0.6.4 → 0.7.0

package/src/cli/notify-cli.ts

@@ -0,0 +1,274 @@
+/**
+ * Notify CLI command handlers.
+ *
+ * Handles `gjc notify` setup/status and the hidden daemon entrypoint.
+ */
+import { createInterface } from "node:readline/promises";
+import { APP_NAME } from "@gajae-code/utils";
+import chalk from "chalk";
+import { Settings } from "../config/settings";
+import { getNotificationConfig, maskToken } from "../notifications/config";
+
+export type NotifyAction = "setup" | "status" | "daemon-internal";
+
+export interface NotifyCommandArgs {
+	action: NotifyAction;
+	smoke?: boolean;
+	rawArgs: string[];
+	token?: string;
+	chatId?: string;
+	redact?: boolean;
+}
+
+export interface NotifyCommandDeps {
+	fetchImpl?: typeof fetch;
+	apiBase?: string;
+	settings?: Settings;
+	setupToken?: string;
+	pollTimeoutMs?: number;
+	pollIntervalMs?: number;
+	setupChatId?: string;
+	setupRedact?: boolean;
+}
+
+interface TelegramApiResponse<T> {
+	ok: boolean;
+	result?: T;
+	description?: string;
+}
+
+interface TelegramUpdate {
+	update_id: number;
+	message?: {
+		chat?: {
+			id?: number | string;
+			type?: string;
+		};
+	};
+}
+
+const DEFAULT_API_BASE = "https://api.telegram.org";
+const DEFAULT_POLL_TIMEOUT_MS = 60_000;
+const DEFAULT_POLL_INTERVAL_MS = 1_000;
+
+export function parseNotifyArgs(args: string[]): NotifyCommandArgs | undefined {
+	if (args.length === 0 || args[0] !== "notify") {
+		return undefined;
+	}
+
+	const action = args[1];
+	if (action === "setup" || action === "status") {
+		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,
+			token: flag("--token"),
+			chatId: flag("--chat-id"),
+			redact: rest.includes("--redact"),
+		};
+	}
+	if (action === "daemon-internal") {
+		return {
+			action,
+			smoke: args.slice(2).includes("--smoke"),
+			rawArgs: args.slice(2),
+		};
+	}
+
+	return { action: "status", rawArgs: args.slice(1) };
+}
+
+export async function runNotifyCommand(cmd: NotifyCommandArgs, deps: NotifyCommandDeps = {}): Promise<void> {
+	switch (cmd.action) {
+		case "setup":
+			await runSetup({
+				...deps,
+				setupToken: deps.setupToken ?? cmd.token,
+				setupChatId: deps.setupChatId ?? cmd.chatId,
+				setupRedact: deps.setupRedact ?? cmd.redact,
+			});
+			return;
+		case "status":
+			await runStatus(deps);
+			return;
+		case "daemon-internal": {
+			const m = await import("../notifications/telegram-daemon-cli");
+			if (cmd.smoke) {
+				await m.runDaemonSmoke();
+			} else {
+				await m.runDaemonInternal(cmd.rawArgs);
+			}
+			return;
+		}
+	}
+}
+
+async function getSettings(deps: NotifyCommandDeps): Promise<Settings> {
+	return deps.settings ?? (await Settings.init());
+}
+
+async function runSetup(deps: NotifyCommandDeps): Promise<void> {
+	const settings = await getSettings(deps);
+	const fetchImpl = deps.fetchImpl ?? globalThis.fetch;
+	const apiBase = deps.apiBase ?? DEFAULT_API_BASE;
+	const token = deps.setupToken ?? (await promptForToken());
+	if (!token.trim()) {
+		throw new Error("Telegram bot token is required.");
+	}
+
+	await callTelegram(fetchImpl, apiBase, token, "getMe", {});
+	process.stdout.write(
+		"Token validated. Message your bot now from the private Telegram chat to pair notifications.\n",
+	);
+
+	let chatId: string;
+	if (deps.setupChatId?.trim()) {
+		chatId = deps.setupChatId.trim();
+		process.stdout.write(`Using provided chat id ${chatId} (non-interactive).\n`);
+	} else {
+		const stale = await getUpdates(fetchImpl, apiBase, token, { timeout: 0, allowed_updates: ["message"] });
+		const offset = nextOffset(stale);
+		chatId = await waitForPrivateChat(fetchImpl, apiBase, token, {
+			offset,
+			pollTimeoutMs: deps.pollTimeoutMs ?? DEFAULT_POLL_TIMEOUT_MS,
+			pollIntervalMs: deps.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS,
+		});
+	}
+
+	settings.set("notifications.telegram.botToken", token);
+	settings.set("notifications.telegram.chatId", chatId);
+	settings.set("notifications.enabled", true);
+	if (deps.setupRedact) settings.set("notifications.redact", true);
+	await settings.flush();
+
+	process.stdout.write(`Notifications enabled. botToken=${maskToken(token)} chatId=${chatId}\n`);
+}
+
+async function promptForToken(): Promise<string> {
+	if (!process.stdin.isTTY) {
+		throw new Error("notify setup requires an interactive TTY unless setupToken is injected.");
+	}
+	const rl = createInterface({ input: process.stdin, output: process.stdout, terminal: true });
+	try {
+		return (await rl.question("Telegram BotFather token: ")).trim();
+	} finally {
+		rl.close();
+	}
+}
+
+async function runStatus(deps: NotifyCommandDeps): Promise<void> {
+	const settings = await getSettings(deps);
+	const cfg = getNotificationConfig(settings);
+	process.stdout.write(
+		`${chalk.bold("Notifications")}\n` +
+			`  enabled: ${cfg.enabled}\n` +
+			`  botToken: ${maskToken(cfg.botToken)}\n` +
+			`  chatId: ${cfg.chatId ?? "(unset)"}\n` +
+			`  redact: ${cfg.redact}\n`,
+	);
+}
+
+async function waitForPrivateChat(
+	fetchImpl: typeof fetch,
+	apiBase: string,
+	token: string,
+	opts: { offset: number | undefined; pollTimeoutMs: number; pollIntervalMs: number },
+): Promise<string> {
+	const deadline = Date.now() + opts.pollTimeoutMs;
+	let offset = opts.offset;
+	let sawRejectedChatType: string | undefined;
+
+	while (Date.now() <= deadline) {
+		const updates = await getUpdates(fetchImpl, apiBase, token, { offset, timeout: 0, allowed_updates: ["message"] });
+		offset = nextOffset(updates, offset);
+		for (const update of updates) {
+			const chat = update.message?.chat;
+			if (!chat) continue;
+			if (chat.type === "private" && chat.id !== undefined) {
+				return String(chat.id);
+			}
+			if (chat.type === "group" || chat.type === "supergroup" || chat.type === "channel") {
+				sawRejectedChatType = chat.type;
+				process.stderr.write(
+					`Rejected ${chat.type} chat. Pairing requires a private Telegram chat with the bot.\n`,
+				);
+			}
+		}
+		if (opts.pollIntervalMs > 0) {
+			await new Promise(resolve =>
+				setTimeout(resolve, Math.min(opts.pollIntervalMs, Math.max(0, deadline - Date.now()))),
+			);
+		}
+	}
+
+	if (sawRejectedChatType) {
+		throw new Error(`Pairing rejected ${sawRejectedChatType} chat; message the bot from a private chat.`);
+	}
+	throw new Error("Timed out waiting for a private Telegram message to pair notifications.");
+}
+
+function nextOffset(updates: TelegramUpdate[], fallback?: number): number | undefined {
+	let max = fallback === undefined ? undefined : fallback - 1;
+	for (const update of updates) {
+		if (typeof update.update_id === "number" && (max === undefined || update.update_id > max)) {
+			max = update.update_id;
+		}
+	}
+	return max === undefined ? fallback : max + 1;
+}
+
+async function getUpdates(
+	fetchImpl: typeof fetch,
+	apiBase: string,
+	token: string,
+	params: Record<string, unknown>,
+): Promise<TelegramUpdate[]> {
+	return await callTelegram<TelegramUpdate[]>(fetchImpl, apiBase, token, "getUpdates", params);
+}
+
+async function callTelegram<T>(
+	fetchImpl: typeof fetch,
+	apiBase: string,
+	token: string,
+	method: string,
+	body: Record<string, unknown>,
+): Promise<T> {
+	const response = await fetchImpl(`${apiBase.replace(/\/$/, "")}/bot${token}/${method}`, {
+		method: "POST",
+		headers: { "content-type": "application/json" },
+		body: JSON.stringify(body),
+	});
+	let payload: TelegramApiResponse<T>;
+	try {
+		payload = (await response.json()) as TelegramApiResponse<T>;
+	} catch {
+		throw new Error(`Telegram ${method} returned invalid JSON.`);
+	}
+	if (!response.ok || !payload.ok) {
+		throw new Error(`Telegram ${method} failed: ${payload.description ?? response.statusText}`);
+	}
+	return payload.result as T;
+}
+
+export function printNotifyHelp(): void {
+	process.stdout.write(`${chalk.bold(`${APP_NAME} notify`)} - Configure Telegram notifications
+
+${chalk.bold("Usage:")}
+  ${APP_NAME} notify setup
+  ${APP_NAME} notify setup --token <botToken> --chat-id <chatId> [--redact]
+  ${APP_NAME} notify status
+
+${chalk.bold("Subcommands:")}
+  setup     Pair a Telegram bot token with a private chat
+  status    Show notification configuration without secrets
+
+${chalk.bold("Examples:")}
+  ${APP_NAME} notify setup
+  ${APP_NAME} notify setup --token <botToken> --chat-id <chatId> [--redact]
+  ${APP_NAME} notify status
+`);
+}

package/src/cli/setup-cli.ts

@@ -6,7 +6,7 @@
 
 import * as path from "node:path";
 import { createInterface } from "node:readline/promises";
-import { SqliteAuthCredentialStore } from "@gajae-code/ai";
+import { AuthStorage, SqliteAuthCredentialStore } from "@gajae-code/ai";
 import { $which, APP_NAME, getAgentDbPath, getPythonEnvDir } from "@gajae-code/utils";
 import { $ } from "bun";
 import chalk from "chalk";
@@ -17,13 +17,15 @@ import {
 	readGjcManagedCodexHooksStatus,
 } from "../hooks/codex-native-hooks-config";
 import { theme } from "../modes/theme/theme";
-import { discoverExternalCredentials, formatDiscoverySummary, importCredentials } from "../setup/credential-import";
+import { formatCredentialAutoImportResult, runExternalCredentialAutoImport } from "../setup/credential-auto-import";
+import { filterAutoImportOAuthCredentials, formatDiscoverySummary } from "../setup/credential-import";
 import {
 	formatHermesSetupResult,
 	type HermesSetupFlags,
 	hermesSetupExitCode,
 	runHermesSetup,
 } from "../setup/hermes-setup";
+import { buildHostPluginSetup, formatHostPluginSetup, type HostPluginKind } from "../setup/host-plugin-setup";
 import {
 	addApiCompatibleProvider,
 	formatProviderPresetList,
@@ -31,7 +33,16 @@ import {
 	parseProviderCompatibility,
 } from "../setup/provider-onboarding";
 
-export type SetupComponent = "credentials" | "defaults" | "hermes" | "hooks" | "provider" | "python" | "stt";
+export type SetupComponent =
+	| "claude"
+	| "codex"
+	| "credentials"
+	| "defaults"
+	| "hermes"
+	| "hooks"
+	| "provider"
+	| "python"
+	| "stt";
 
 export interface SetupCommandArgs {
 	component: SetupComponent;
@@ -63,10 +74,21 @@ export interface SetupCommandArgs {
 		profileDir?: string;
 		yes?: boolean;
 		dryRun?: boolean;
+		keychain?: boolean;
 	};
 }
 
-const VALID_COMPONENTS: SetupComponent[] = ["credentials", "defaults", "hermes", "hooks", "provider", "python", "stt"];
+const VALID_COMPONENTS: SetupComponent[] = [
+	"claude",
+	"codex",
+	"credentials",
+	"defaults",
+	"hermes",
+	"hooks",
+	"provider",
+	"python",
+	"stt",
+];
 
 function hasProviderSetupFlags(flags: SetupCommandArgs["flags"]): boolean {
 	return (
@@ -123,6 +145,8 @@ export function parseSetupArgs(args: string[]): SetupCommandArgs | undefined {
 			flags.yes = true;
 		} else if (arg === "--dry-run") {
 			flags.dryRun = true;
+		} else if (arg === "--keychain") {
+			flags.keychain = true;
 		} else if (arg === "--root") {
 			flags.root = [...(flags.root ?? []), args[++i] ?? ""];
 		} else if (arg === "--repo") {
@@ -235,6 +259,12 @@ async function checkPythonSetup(): Promise<PythonCheckResult> {
 export async function runSetupCommand(cmd: SetupCommandArgs): Promise<void> {
 	rejectProviderFlagsOutsideProvider(cmd.component, cmd.flags);
 	switch (cmd.component) {
+		case "claude":
+			handleHostPluginSetup("claude", cmd.flags);
+			break;
+		case "codex":
+			handleHostPluginSetup("codex", cmd.flags);
+			break;
 		case "defaults":
 			await handleDefaultsSetup(cmd.flags);
 			break;
@@ -279,6 +309,22 @@ async function handleHermesSetup(flags: HermesSetupFlags): Promise<void> {
 		process.exit(hermesSetupExitCode(error));
 	}
 }
+
+function handleHostPluginSetup(host: HostPluginKind, flags: SetupCommandArgs["flags"]): void {
+	const result = buildHostPluginSetup(host, {
+		json: flags.json,
+		check: flags.check,
+		root: flags.root,
+		repo: flags.repo,
+	});
+	if (flags.json) {
+		process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+		return;
+	}
+	const label = host === "claude" ? "Claude Code" : "Codex";
+	process.stdout.write(`${chalk.green(`${theme.status.success} ${label} plugin setup ready`)}\n`);
+	process.stdout.write(`${chalk.dim(formatHostPluginSetup(result))}\n`);
+}
 async function handleProviderSetup(flags: {
 	json?: boolean;
 	force?: boolean;
@@ -516,99 +562,141 @@ async function confirmImport(count: number): Promise<boolean> {
  * gjc credential store after a redacted preview + confirmation. Falls back to
  * manual-setup guidance when nothing importable is found.
  */
-async function handleCredentialsSetup(flags: { json?: boolean; yes?: boolean; dryRun?: boolean }): Promise<void> {
-	const result = await discoverExternalCredentials();
-	const redactedPlan = {
-		importable: result.importable.map(c => ({
-			provider: c.provider,
-			kind: c.kind,
-			source: c.source,
-			identity: c.identity,
-			expiresAt: c.expiresAt,
-			redactedToken: c.redactedToken,
-		})),
-		skipped: result.skipped,
-		environment: result.environment,
-	};
+export interface CredentialsSetupDependencies {
+	openStore?: typeof SqliteAuthCredentialStore.open;
+	createAuthStorage?: (store: Awaited<ReturnType<typeof SqliteAuthCredentialStore.open>>) => AuthStorage;
+	discover?: Parameters<typeof runExternalCredentialAutoImport>[0]["discover"];
+}
 
-	if (result.importable.length === 0) {
-		if (flags.json) {
-			process.stdout.write(`${JSON.stringify({ ...redactedPlan, imported: [] })}\n`);
+export async function handleCredentialsSetup(
+	flags: {
+		json?: boolean;
+		yes?: boolean;
+		dryRun?: boolean;
+		keychain?: boolean;
+	},
+	deps: CredentialsSetupDependencies = {},
+): Promise<void> {
+	const discoveryOptions = flags.keychain ? undefined : { readClaudeKeychain: async () => null };
+	const store = await (deps.openStore ?? SqliteAuthCredentialStore.open)(getAgentDbPath());
+	const authStorage = deps.createAuthStorage?.(store) ?? new AuthStorage(store);
+	await authStorage.reload();
+	try {
+		const preview = await runExternalCredentialAutoImport({
+			authStorage: {
+				importCredentialIfAbsent: async () => ({
+					inserted: false,
+					reason: "skipped-existing",
+					provider: "",
+					entries: [],
+				}),
+			},
+			discover: deps.discover,
+			discoveryOptions,
+			trigger: "setup-cli",
+		});
+		const result = preview.discovery ?? { importable: [], skipped: [], environment: [] };
+		const candidates = filterAutoImportOAuthCredentials(result.importable);
+		const filteredResult = { ...result, importable: candidates };
+		const redactedPlan = {
+			importable: candidates.map(c => ({
+				provider: c.provider,
+				kind: c.kind,
+				source: c.source,
+				identity: c.identity,
+				expiresAt: c.expiresAt,
+				redactedToken: c.redactedToken,
+			})),
+			skipped: result.skipped,
+			environment: result.environment,
+			keychainChecked: flags.keychain === true,
+		};
+
+		if (!flags.keychain && !flags.json) {
+			process.stdout.write(chalk.dim("Claude Keychain not checked (pass --keychain to include it)\n"));
+		}
+
+		if (candidates.length === 0) {
+			if (flags.json) {
+				process.stdout.write(`${JSON.stringify({ ...redactedPlan, imported: [] })}\n`);
+				return;
+			}
+			for (const line of formatDiscoverySummary(filteredResult)) process.stdout.write(`  ${line}\n`);
+			process.stdout.write(
+				chalk.yellow(
+					`\nNo importable Claude/Codex credentials found. Continue with manual setup:\n` +
+						`  ${APP_NAME} setup provider   (add an API-compatible provider)\n` +
+						`  ${APP_NAME} (then /login)     (interactive OAuth/subscription login)\n`,
+				),
+			);
 			return;
 		}
-		for (const line of formatDiscoverySummary(result)) process.stdout.write(`  ${line}\n`);
-		process.stdout.write(
-			chalk.yellow(
-				`\nNo importable Claude/Codex credentials found. Continue with manual setup:\n` +
-					`  ${APP_NAME} setup provider   (add an API-compatible provider)\n` +
-					`  ${APP_NAME} (then /login)     (interactive OAuth/subscription login)\n`,
-			),
-		);
-		return;
-	}
 
-	if (!flags.json) {
-		process.stdout.write(chalk.bold("Discovered credentials (redacted):\n"));
-		for (const line of formatDiscoverySummary(result)) process.stdout.write(`  ${line}\n`);
-	}
+		if (!flags.json) {
+			process.stdout.write(chalk.bold("Discovered credentials (redacted):\n"));
+			for (const line of formatDiscoverySummary(filteredResult)) process.stdout.write(`  ${line}\n`);
+		}
 
-	if (flags.dryRun) {
-		if (flags.json) process.stdout.write(`${JSON.stringify({ ...redactedPlan, dryRun: true, imported: [] })}\n`);
-		else process.stdout.write(chalk.dim(`\nDry run — no credentials imported.\n`));
-		return;
-	}
+		if (flags.dryRun) {
+			if (flags.json) process.stdout.write(`${JSON.stringify({ ...redactedPlan, dryRun: true, imported: [] })}\n`);
+			else process.stdout.write(chalk.dim(`\nDry run — no credentials imported.\n`));
+			return;
+		}
+
+		const confirmed = flags.yes || (await confirmImport(candidates.length));
+		if (!confirmed) {
+			if (flags.json) {
+				process.stdout.write(`${JSON.stringify({ ...redactedPlan, imported: [] })}\n`);
+				return;
+			}
+			process.stdout.write(chalk.dim(`\nImport cancelled. Re-run with --yes to import non-interactively.\n`));
+			return;
+		}
+
+		const summary = await runExternalCredentialAutoImport({
+			authStorage,
+			discover: deps.discover,
+			discoveryOptions,
+			trigger: "setup-cli",
+		});
 
-	const confirmed = flags.yes || (await confirmImport(result.importable.length));
-	if (!confirmed) {
 		if (flags.json) {
-			process.stdout.write(`${JSON.stringify({ ...redactedPlan, imported: [] })}\n`);
+			process.stdout.write(
+				`${JSON.stringify({
+					...redactedPlan,
+					imported: summary.imported.map(c => ({ provider: c.provider, kind: c.kind, source: c.source })),
+					skippedImport: summary.skipped.map(s => ({
+						provider: s.credential.provider,
+						source: s.credential.source,
+						reason: s.reason,
+					})),
+					failed: summary.failures.map(f => ({
+						provider: f.credential?.provider,
+						source: f.credential?.source ?? f.source,
+						error: f.failureClass,
+					})),
+				})}\n`,
+			);
+			if (summary.failures.length > 0) process.exitCode = 1;
 			return;
 		}
-		process.stdout.write(chalk.dim(`\nImport cancelled. Re-run with --yes to import non-interactively.\n`));
-		return;
-	}
 
-	const store = await SqliteAuthCredentialStore.open(getAgentDbPath());
-	let summary: Awaited<ReturnType<typeof importCredentials>>;
-	try {
-		summary = await importCredentials(result.importable, (provider, credential) =>
-			store.upsertAuthCredentialForProvider(provider, credential),
-		);
+		for (const credential of summary.imported) {
+			process.stdout.write(
+				`${chalk.green(`${theme.status.success} imported`)} ${formatCredentialSummaryLine(credential)}\n`,
+			);
+		}
+		for (const line of formatCredentialAutoImportResult({ ...summary, imported: [], skipped: [] })) {
+			process.stdout.write(`${chalk.dim(line)}\n`);
+		}
+		if (summary.failures.length > 0) {
+			process.exitCode = 1;
+			return;
+		}
+		process.stdout.write(chalk.dim(`\nCredentials saved to ${getAgentDbPath()}\n`));
 	} finally {
 		store.close();
 	}
-
-	if (flags.json) {
-		process.stdout.write(
-			`${JSON.stringify({
-				...redactedPlan,
-				imported: summary.imported.map(c => ({ provider: c.provider, kind: c.kind, source: c.source })),
-				failed: summary.failed.map(f => ({
-					provider: f.credential.provider,
-					source: f.credential.source,
-					error: f.error,
-				})),
-			})}\n`,
-		);
-		if (summary.failed.length > 0) process.exitCode = 1;
-		return;
-	}
-
-	for (const credential of summary.imported) {
-		process.stdout.write(
-			`${chalk.green(`${theme.status.success} imported`)} ${formatCredentialSummaryLine(credential)}\n`,
-		);
-	}
-	for (const failure of summary.failed) {
-		process.stdout.write(
-			`${chalk.red(`${theme.status.error} failed`)} ${failure.credential.provider} (${failure.credential.source}): ${failure.error}\n`,
-		);
-	}
-	if (summary.failed.length > 0) {
-		process.exitCode = 1;
-		return;
-	}
-	process.stdout.write(chalk.dim(`\nCredentials saved to ${getAgentDbPath()}\n`));
 }
 
 function formatCredentialSummaryLine(credential: { provider: string; kind: string; source: string }): string {
@@ -669,6 +757,7 @@ ${chalk.bold("Options:")}
   --profile-dir     Hermes profile directory for full setup install
   --dry-run         Preview discovered credentials without importing (credentials)
   -y, --yes         Import discovered credentials without an interactive prompt (credentials)
+  --keychain        Include Claude macOS Keychain when discovering credentials
 
 ${chalk.bold("Examples:")}
   ${APP_NAME} setup                  Install bundled GJC default workflow skills

package/src/cli.ts

@@ -35,6 +35,8 @@ const commands: CommandEntry[] = [
 	{ name: "gc", load: () => import("./commands/gc").then(m => m.default) },
 	{ name: "ralplan", load: () => import("./commands/ralplan").then(m => m.default) },
 	{ name: "config", load: () => import("./commands/config").then(m => m.default) },
+	{ name: "notify", load: () => import("./commands/notify").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: "mcp-serve", load: () => import("./commands/mcp-serve").then(m => m.default) },
 	{
@@ -43,6 +45,7 @@ const commands: CommandEntry[] = [
 		load: () => import("./commands/contribution-prep").then(m => m.default),
 	},
 	{ name: "deep-interview", load: () => import("./commands/deep-interview").then(m => m.default) },
+	{ name: "migrate", load: () => import("./commands/migrate").then(m => m.default) },
 	{ name: "rlm", load: () => import("./commands/rlm").then(m => m.default) },
 	{ name: "update", load: () => import("./commands/update").then(m => m.default) },
 	{ name: "launch", load: () => import("./commands/launch").then(m => m.default) },

package/src/commands/daemon.ts

@@ -0,0 +1,47 @@
+/**
+ * Manage GJC background daemons (status/list/stop/reload).
+ */
+import { Args, Command, Flags } from "@gajae-code/utils/cli";
+import { type DaemonCliAction, type DaemonCommandArgs, runDaemonCommand } from "../cli/daemon-cli";
+import type { DaemonKind } from "../daemon/control-types";
+import { initTheme } from "../modes/theme/theme";
+
+const ACTIONS: DaemonCliAction[] = ["list", "status", "stop", "reload"];
+
+export default class Daemon extends Command {
+	static description = "Manage GJC background daemons (status, list, stop, reload)";
+
+	static args = {
+		action: Args.string({ description: "Daemon action", required: false, options: ACTIONS }),
+		kind: Args.string({ description: "Daemon kind(s) to target", required: false, multiple: true }),
+	};
+
+	static flags = {
+		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" }),
+		"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" }),
+	};
+
+	async run(): Promise<void> {
+		const { args, flags } = await this.parse(Daemon);
+		const action = (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 = {
+			action,
+			kinds,
+			all: Boolean(flags.all),
+			json: Boolean(flags.json),
+			force: Boolean(flags.force),
+			gracefulTimeoutMs: flagRec["graceful-timeout-ms"] as number | undefined,
+			killTimeoutMs: flagRec["kill-timeout-ms"] as number | undefined,
+			spawnIfStopped: flagRec["spawn-if-stopped"] as boolean | undefined,
+		};
+
+		await initTheme();
+		await runDaemonCommand(cmd);
+	}
+}

package/src/commands/deep-interview.ts

@@ -11,11 +11,11 @@ export default class DeepInterview extends Command {
 		threshold: Flags.string({ description: "Override ambiguity threshold for kickoff" }),
 		"threshold-source": Flags.string({ description: "Describe the threshold override source" }),
 		"session-id": Flags.string({
-			description: "Route state/spec handoff through a session-scoped .gjc state directory",
+			description: "Route state/spec handoff through a session-scoped .gjc/_session-{sessionid} directory",
 		}),
 		write: Flags.boolean({ description: "Persist a final deep-interview spec through the sanctioned GJC CLI/API" }),
 		stage: Flags.string({ description: 'Spec stage for --write (currently "final")' }),
-		slug: Flags.string({ description: "Safe slug for .gjc/specs/deep-interview-<slug>.md" }),
+		slug: Flags.string({ description: "Safe slug for .gjc/_session-{sessionid}/specs/deep-interview-<slug>.md" }),
 		spec: Flags.string({ description: "Final spec markdown or a path to the final spec markdown" }),
 		handoff: Flags.string({ description: 'After --write, hand off to a workflow target (currently "ralplan")' }),
 		deliberate: Flags.boolean({