@gajae-code/coding-agent 0.11.1 → 0.11.3

package/src/async/job-manager.ts

@@ -12,6 +12,7 @@ const DELIVERY_MAX_TEXT_BYTES = 64 * 1024;
 const DELIVERY_PREVIEW_HEAD_BYTES = 32 * 1024;
 const DELIVERY_PREVIEW_TAIL_BYTES = 32 * 1024;
 const DELIVERY_MAX_ATTEMPTS = 3;
+const MAX_DEAD_LETTERED_DELIVERIES = 50;
 
 export interface AsyncJob {
 	id: string;
@@ -207,6 +208,12 @@ interface AsyncJobDelivery {
 	promise?: Promise<void>;
 }
 
+interface DeadLetteredDelivery {
+	jobId: string;
+	attempt: number;
+	lastError?: string;
+}
+
 export interface AsyncJobDeliveryState {
 	queued: number;
 	delivering: boolean;
@@ -381,7 +388,8 @@ export class AsyncJobManager {
 	 * resume fails closed with reason "no_runner".
 	 */
 	readonly #descriptorResumeRunners = new Map<string, ResumeRunner>();
-	readonly #deadLetteredDeliveries = new Map<string, AsyncJobDelivery>();
+	readonly #deadLetteredDeliveries = new Map<string, DeadLetteredDelivery>();
+	readonly #deadLetteredDeliveryOwners = new Map<string, string | undefined>();
 	readonly #ownerSubagentShutdownLeases = new Map<string, OwnerSubagentShutdownLeaseState>();
 	#ownerSubagentShutdownSeq = 0;
 	#lastDisposeDiagnostics: AsyncJobDisposeDiagnostics = { stuckJobIds: [], deliveriesDrained: true };
@@ -1333,12 +1341,16 @@ export class AsyncJobManager {
 	}
 
 	getDeliveryState(filter?: AsyncJobFilter): AsyncJobDeliveryState {
+		this.#expireMonitorTombstones();
+		this.#pruneEvictedDeadLetters();
 		const deliveries = this.#filterDeliveries(filter);
 		const inFlightDeliveries = this.#filterInFlightDeliveries(filter);
 		const ownerId = filter?.ownerId;
-		const deadLettered = Array.from(this.#deadLetteredDeliveries.values()).filter(
-			delivery => !ownerId || delivery.ownerId === ownerId,
-		).length;
+		const deadLettered = ownerId
+			? Array.from(this.#deadLetteredDeliveries.keys()).filter(
+					jobId => this.#deadLetteredDeliveryOwners.get(jobId) === ownerId,
+				).length
+			: this.#deadLetteredDeliveries.size;
 		const nextRetryAt = deliveries.reduce<number | undefined>((next, delivery) => {
 			if (next === undefined) return delivery.nextAttemptAt;
 			return Math.min(next, delivery.nextAttemptAt);
@@ -1553,6 +1565,7 @@ export class AsyncJobManager {
 		this.#deliveries.length = 0;
 		this.#inFlightDeliveries.length = 0;
 		this.#deadLetteredDeliveries.clear();
+		this.#deadLetteredDeliveryOwners.clear();
 		this.#suppressedDeliveries.clear();
 		this.#watchedJobs.clear();
 		this.#outputState.clear();
@@ -1615,12 +1628,15 @@ export class AsyncJobManager {
 	}
 
 	#evictJob(jobId: string): void {
+		this.#expireMonitorTombstones();
 		this.#recordMonitorTombstone(jobId);
 		this.#runLifecycle(jobId, "evict");
 		this.#purgeTerminalSubagentStateForJob(jobId);
 		this.#jobs.delete(jobId);
 		this.#lifecycles.delete(jobId);
 		this.#lifecyclePhases.delete(jobId);
+		this.#deadLetteredDeliveries.delete(jobId);
+		this.#deadLetteredDeliveryOwners.delete(jobId);
 		this.#suppressedDeliveries.delete(jobId);
 		this.#watchedJobs.delete(jobId);
 		this.#outputState.delete(jobId);
@@ -1700,6 +1716,33 @@ export class AsyncJobManager {
 		return this.#isDeliveryAcknowledged(jobId) || this.#watchedJobs.has(jobId);
 	}
 
+	#pruneEvictedDeadLetters(): void {
+		for (const jobId of this.#deadLetteredDeliveries.keys()) {
+			if (this.#jobs.has(jobId)) continue;
+			this.#deadLetteredDeliveries.delete(jobId);
+			this.#deadLetteredDeliveryOwners.delete(jobId);
+		}
+	}
+
+	#recordDeadLetter(delivery: AsyncJobDelivery): void {
+		this.#pruneEvictedDeadLetters();
+		if (!this.#jobs.has(delivery.jobId)) return;
+		this.#deadLetteredDeliveries.delete(delivery.jobId);
+		this.#deadLetteredDeliveryOwners.delete(delivery.jobId);
+		this.#deadLetteredDeliveries.set(delivery.jobId, {
+			jobId: delivery.jobId,
+			attempt: delivery.attempt,
+			lastError: delivery.lastError,
+		});
+		this.#deadLetteredDeliveryOwners.set(delivery.jobId, delivery.ownerId);
+		while (this.#deadLetteredDeliveries.size > MAX_DEAD_LETTERED_DELIVERIES) {
+			const oldestJobId = this.#deadLetteredDeliveries.keys().next().value;
+			if (oldestJobId === undefined) return;
+			this.#deadLetteredDeliveries.delete(oldestJobId);
+			this.#deadLetteredDeliveryOwners.delete(oldestJobId);
+		}
+	}
+
 	#enqueueDelivery(jobId: string, text: string): void {
 		// Skip delivery if already acknowledged
 		if (this.#isDeliveryAcknowledged(jobId)) {
@@ -1717,7 +1760,7 @@ export class AsyncJobManager {
 		});
 		while (this.#deliveries.length > DEFAULT_MAX_DELIVERY_QUEUE) {
 			const dropped = this.#deliveries.shift();
-			if (dropped) this.#deadLetteredDeliveries.set(dropped.jobId, dropped);
+			if (dropped) this.#recordDeadLetter(dropped);
 		}
 		this.#ensureDeliveryLoop();
 	}
@@ -1781,7 +1824,7 @@ export class AsyncJobManager {
 				delivery.attempt += 1;
 				delivery.lastError = error instanceof Error ? error.message : String(error);
 				if (delivery.attempt >= DELIVERY_MAX_ATTEMPTS) {
-					this.#deadLetteredDeliveries.set(delivery.jobId, delivery);
+					this.#recordDeadLetter(delivery);
 					logger.warn("Async job completion delivery reached retry cap", {
 						jobId: delivery.jobId,
 						attempt: delivery.attempt,

package/src/cli/config-cli.ts

@@ -5,7 +5,10 @@
  * Uses the settings schema as the source of truth for available settings.
  */
 
+import * as fs from "node:fs/promises";
+import type * as path from "node:path";
 import { APP_NAME, getAgentDir } from "@gajae-code/utils";
+import { YAML } from "bun";
 import chalk from "chalk";
 import {
 	getDefault,
@@ -25,7 +28,7 @@ import { initXdg } from "./commands/init-xdg";
 // Types
 // =============================================================================
 
-export type ConfigAction = "list" | "get" | "set" | "reset" | "path" | "init-xdg";
+export type ConfigAction = "list" | "get" | "set" | "reset" | "path" | "doctor" | "init-xdg";
 
 export interface ConfigCommandArgs {
 	action: ConfigAction;
@@ -111,7 +114,7 @@ function getSettingValues(def: CliSettingDef): readonly string[] | undefined {
 // Argument Parser
 // =============================================================================
 
-const VALID_ACTIONS: ConfigAction[] = ["list", "get", "set", "reset", "path", "init-xdg"];
+const VALID_ACTIONS: ConfigAction[] = ["list", "get", "set", "reset", "path", "doctor", "init-xdg"];
 
 /**
  * Parse config subcommand arguments.
@@ -299,6 +302,9 @@ export async function runConfigCommand(cmd: ConfigCommandArgs): Promise<void> {
 		case "path":
 			handlePath();
 			break;
+		case "doctor":
+			handleDoctor(cmd.flags);
+			break;
 		case "init-xdg":
 			await initXdg();
 			break;
@@ -443,6 +449,70 @@ function handlePath(): void {
 	console.log(getAgentDir());
 }
 
+function handleDoctor(flags: { json?: boolean }): void {
+	const report = settings.getSchemaReport();
+	if (flags.json) {
+		console.log(JSON.stringify(report, null, 2));
+		return;
+	}
+	if (report.issues.length === 0) {
+		console.log(chalk.green("Settings schema is healthy."));
+		return;
+	}
+	for (const issue of report.issues) console.log(`${issue.kind}\t${issue.path}\t${issue.detail}`);
+}
+
+type ConfigDoctorReport = {
+	unknownKeys: string[];
+	invalidValues: Array<{ path: string; value: unknown }>;
+	legacyShapes: string[];
+};
+
+function flattenConfig(value: unknown, prefix = ""): Array<[string, unknown]> {
+	if (prefix && ALL_SETTING_PATHS.includes(prefix as SettingPath)) return [[prefix, value]];
+	if (value === null || typeof value !== "object" || Array.isArray(value)) return prefix ? [[prefix, value]] : [];
+	return Object.entries(value).flatMap(([key, child]) => flattenConfig(child, prefix ? `${prefix}.${key}` : key));
+}
+
+function matchesSettingType(path: SettingPath, value: unknown): boolean {
+	const definition = SETTINGS_SCHEMA[path];
+	switch (definition.type) {
+		case "string":
+		case "enum":
+			return (
+				typeof value === "string" && (definition.type !== "enum" || getEnumValues(path)?.includes(value) === true)
+			);
+		case "number":
+			return typeof value === "number" && Number.isFinite(value);
+		case "boolean":
+			return typeof value === "boolean";
+		case "array":
+			return Array.isArray(value);
+		case "record":
+			return value !== null && typeof value === "object" && !Array.isArray(value);
+	}
+}
+
+export async function inspectConfigFile(configPath: string): Promise<ConfigDoctorReport> {
+	const report: ConfigDoctorReport = { unknownKeys: [], invalidValues: [], legacyShapes: [] };
+	try {
+		const raw = YAML.parse(await fs.readFile(configPath, "utf8"));
+		if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
+			report.legacyShapes.push("config root is not a mapping");
+			return report;
+		}
+		for (const [settingPath, value] of flattenConfig(raw)) {
+			if (!ALL_SETTING_PATHS.includes(settingPath as SettingPath)) report.unknownKeys.push(settingPath);
+			else if (!matchesSettingType(settingPath as SettingPath, value))
+				report.invalidValues.push({ path: settingPath, value: redactConfigValue(settingPath, value) });
+		}
+	} catch (error) {
+		if ((error as NodeJS.ErrnoException).code !== "ENOENT")
+			report.legacyShapes.push(`unable to parse config: ${String(error)}`);
+	}
+	return report;
+}
+
 // =============================================================================
 // Help
 // =============================================================================
@@ -455,8 +525,10 @@ ${chalk.bold("Commands:")}
   get <key>          Get a specific setting value
   set <key> <value>  Set a setting value
   reset <key>        Reset a setting to its default value
+  doctor             Report unknown, invalid, and pending settings migrations
   path               Print the config directory path
   init-xdg           Initialize XDG Base Directory structure
+  doctor             Report unknown, invalid, and legacy config entries
 
 ${chalk.bold("Options:")}
   --json             Output as JSON
@@ -472,6 +544,7 @@ ${chalk.bold("Examples:")}
   ${APP_NAME} config list --json
   ${APP_NAME} config get auth.broker.token --show-secrets
   ${APP_NAME} config init-xdg
+  ${APP_NAME} config doctor --json
 
 ${chalk.bold("Boolean Values:")}
   true, false, yes, no, on, off, 1, 0

package/src/cli/launch-disposition.ts

@@ -0,0 +1,42 @@
+export type LaunchMode = "text" | "json" | "acp";
+
+export interface LaunchDisposition {
+	autoPrint: boolean;
+	isInteractive: boolean;
+	/** Set when an interactive launch is impossible (non-TTY stdin, nothing to run). */
+	nonInteractiveError?: string;
+}
+
+/**
+ * Decides between interactive, auto-print, and fail-fast launches.
+ *
+ * A non-TTY stdin means the TUI can never receive input, so an interactive
+ * launch would execute the initial prompt and then block in the event loop
+ * forever. Prepared command-line input degrades to print mode; without any
+ * input to run we fail fast instead of hanging. Explicit `--print` and
+ * `--mode` launches are left untouched.
+ */
+export function resolveLaunchDisposition(args: {
+	stdinIsTTY: boolean | undefined;
+	pipedInput: string | undefined;
+	hasPreparedInput: boolean;
+	print: boolean;
+	mode: LaunchMode | undefined;
+}): LaunchDisposition {
+	const explicitNonInteractive = args.print || args.mode !== undefined;
+	const hasPreparedInput = args.pipedInput !== undefined || args.hasPreparedInput;
+	const hasNonTtyStdin = args.stdinIsTTY !== true;
+	const autoPrint = !explicitNonInteractive && hasNonTtyStdin && hasPreparedInput;
+	const isInteractive = !explicitNonInteractive && !autoPrint;
+
+	if (isInteractive && args.stdinIsTTY !== true) {
+		return {
+			autoPrint: false,
+			isInteractive: false,
+			nonInteractiveError:
+				"stdin is not a TTY and no prompt or prepared input was provided; use -p/--print (or pass a prompt or @file) for non-interactive runs.",
+		};
+	}
+
+	return { autoPrint, isInteractive };
+}

package/src/cli/notify-cli.ts

@@ -75,6 +75,7 @@ export interface NotifyCommandDeps {
 	tokenPrompt?: () => Promise<string>;
 	setExitCode?: (code: number) => void;
 	exitProcess?: (code: number) => void;
+	valuePrompt?: (label: string, masked: boolean) => Promise<string>;
 	/** Optional daemon ownership facts collected by an embedding host. */
 	setupPreflight?: TelegramSetupPreflight;
 	/** Injectable timers and cancellation for setup pairing. */
@@ -99,6 +100,27 @@ export function parseNotifyArgs(args: string[]): NotifyCommandArgs | undefined {
 			const i = rest.indexOf(name);
 			return i >= 0 ? rest[i + 1] : undefined;
 		};
+		const valueFlags = [
+			"--token",
+			"--chat-id",
+			"--discord-bot-token",
+			"--discord-application-id",
+			"--discord-guild-id",
+			"--discord-parent-channel-id",
+			"--slack-bot-token",
+			"--slack-app-token",
+			"--slack-workspace-id",
+			"--slack-channel-id",
+			"--slack-authorized-user-id",
+		];
+		if (
+			valueFlags.some(name => {
+				const index = rest.indexOf(name);
+				const value = index >= 0 ? rest[index + 1] : undefined;
+				return index >= 0 && (!value || value.startsWith("--"));
+			})
+		)
+			return undefined;
 		const provider = rest[0]?.startsWith("--") ? undefined : rest[0];
 		if (provider !== undefined && provider !== "telegram" && provider !== "discord" && provider !== "slack") {
 			return undefined;
@@ -144,7 +166,7 @@ export function parseNotifyArgs(args: string[]): NotifyCommandArgs | undefined {
 		};
 	}
 
-	return { action: "status", rawArgs: args.slice(1) };
+	return undefined;
 }
 
 export async function runNotifyCommand(cmd: NotifyCommandArgs, deps: NotifyCommandDeps = {}): Promise<void> {
@@ -221,22 +243,41 @@ async function runSetup(cmd: NotifyCommandArgs, deps: NotifyCommandDeps): Promis
 
 function requiredSetupValue(value: string | undefined, flag: string): string {
 	if (!value?.trim()) throw new Error(`${flag} is required for non-interactive setup.`);
+	if (value.trim().startsWith("--")) throw new Error(`${flag} must not start with --.`);
 	return value.trim();
 }
 
+async function promptSetupValue(
+	value: string | undefined,
+	flag: string,
+	masked: boolean,
+	deps: NotifyCommandDeps,
+): Promise<string> {
+	if (value?.trim()) return requiredSetupValue(value, flag);
+	if (!resolveSetupInteractive(deps)) return requiredSetupValue(value, flag);
+	return requiredSetupValue(await (deps.valuePrompt ?? promptForValue)(`${flag.slice(2)}: `, masked), flag);
+}
+
 async function runDiscordSetup(cmd: NotifyCommandArgs, deps: NotifyCommandDeps): Promise<void> {
-	const botToken = requiredSetupValue(cmd.discordBotToken, "--discord-bot-token");
-	const applicationId = requiredSetupValue(cmd.discordApplicationId, "--discord-application-id");
-	const guildId = requiredSetupValue(cmd.discordGuildId, "--discord-guild-id");
-	const parentChannelId = requiredSetupValue(cmd.discordParentChannelId, "--discord-parent-channel-id");
+	const botToken = await promptSetupValue(cmd.discordBotToken, "--discord-bot-token", true, deps);
+	const applicationId = await promptSetupValue(cmd.discordApplicationId, "--discord-application-id", false, deps);
+	const guildId = await promptSetupValue(cmd.discordGuildId, "--discord-guild-id", false, deps);
+	const parentChannelId = await promptSetupValue(
+		cmd.discordParentChannelId,
+		"--discord-parent-channel-id",
+		false,
+		deps,
+	);
 	const settings = await getSettings(deps);
-	settings.set("notifications.discord.botToken", botToken);
-	settings.set("notifications.discord.applicationId", applicationId);
-	settings.set("notifications.discord.guildId", guildId);
-	settings.set("notifications.discord.parentChannelId", parentChannelId);
-	settings.set("notifications.enabled", true);
-	if (cmd.redact) settings.set("notifications.redact", true);
-	await settings.flushOrThrow();
+	const patches: SettingsAtomicPatch[] = [
+		{ path: "notifications.discord.botToken", op: "set", value: botToken },
+		{ path: "notifications.discord.applicationId", op: "set", value: applicationId },
+		{ path: "notifications.discord.guildId", op: "set", value: guildId },
+		{ path: "notifications.discord.parentChannelId", op: "set", value: parentChannelId },
+		{ path: "notifications.enabled", op: "set", value: true },
+	];
+	if (cmd.redact) patches.push({ path: "notifications.redact", op: "set", value: true });
+	await settings.commitAtomicBatch(patches);
 	const daemon = await ensureConfiguredProviderDaemon("discord", settings, deps);
 	process.stdout.write(
 		`Discord notifications enabled. botToken=${maskToken(botToken)} applicationId=${applicationId} guildId=${guildId} parentChannelId=${parentChannelId} daemon=${daemon}\n`,
@@ -244,20 +285,24 @@ async function runDiscordSetup(cmd: NotifyCommandArgs, deps: NotifyCommandDeps):
 }
 
 async function runSlackSetup(cmd: NotifyCommandArgs, deps: NotifyCommandDeps): Promise<void> {
-	const botToken = requiredSetupValue(cmd.slackBotToken, "--slack-bot-token");
-	const appToken = requiredSetupValue(cmd.slackAppToken, "--slack-app-token");
-	const workspaceId = requiredSetupValue(cmd.slackWorkspaceId, "--slack-workspace-id");
-	const channelId = requiredSetupValue(cmd.slackChannelId, "--slack-channel-id");
+	const botToken = await promptSetupValue(cmd.slackBotToken, "--slack-bot-token", true, deps);
+	const appToken = await promptSetupValue(cmd.slackAppToken, "--slack-app-token", true, deps);
+	const workspaceId = await promptSetupValue(cmd.slackWorkspaceId, "--slack-workspace-id", false, deps);
+	const channelId = await promptSetupValue(cmd.slackChannelId, "--slack-channel-id", false, deps);
 	const authorizedUserId = cmd.slackAuthorizedUserId?.trim() || undefined;
 	const settings = await getSettings(deps);
-	settings.set("notifications.slack.botToken", botToken);
-	settings.set("notifications.slack.appToken", appToken);
-	settings.set("notifications.slack.workspaceId", workspaceId);
-	settings.set("notifications.slack.channelId", channelId);
-	settings.set("notifications.slack.authorizedUserId", authorizedUserId);
-	settings.set("notifications.enabled", true);
-	if (cmd.redact) settings.set("notifications.redact", true);
-	await settings.flushOrThrow();
+	const patches: SettingsAtomicPatch[] = [
+		{ path: "notifications.slack.botToken", op: "set", value: botToken },
+		{ path: "notifications.slack.appToken", op: "set", value: appToken },
+		{ path: "notifications.slack.workspaceId", op: "set", value: workspaceId },
+		{ path: "notifications.slack.channelId", op: "set", value: channelId },
+		authorizedUserId === undefined
+			? { path: "notifications.slack.authorizedUserId", op: "unset" }
+			: { path: "notifications.slack.authorizedUserId", op: "set", value: authorizedUserId },
+		{ path: "notifications.enabled", op: "set", value: true },
+	];
+	if (cmd.redact) patches.push({ path: "notifications.redact", op: "set", value: true });
+	await settings.commitAtomicBatch(patches);
 	const daemon = await ensureConfiguredProviderDaemon("slack", settings, deps);
 	process.stdout.write(
 		`Slack notifications enabled. botToken=${maskToken(botToken)} appToken=${maskToken(appToken)} workspaceId=${workspaceId} channelId=${channelId} authorizedUserId=${authorizedUserId ?? "(unset; inbound denied)"} daemon=${daemon}\n`,
@@ -437,7 +482,8 @@ type TokenPromptInput = NodeJS.ReadStream & {
 
 type TokenPromptOutput = Pick<NodeJS.WriteStream, "write">;
 
-export async function promptForToken(
+async function promptForMaskedValue(
+	label: string,
 	input: TokenPromptInput = process.stdin,
 	output: TokenPromptOutput = process.stdout,
 ): Promise<string> {
@@ -448,7 +494,7 @@ export async function promptForToken(
 		throw new Error("notify setup requires a TTY with raw input support unless setupToken is injected.");
 	}
 
-	output.write("Telegram BotFather token: ");
+	output.write(label);
 	const wasRaw = input.isRaw === true;
 	input.setRawMode(true);
 
@@ -503,6 +549,26 @@ export async function promptForToken(
 	});
 }
 
+export async function promptForToken(
+	input: TokenPromptInput = process.stdin,
+	output: TokenPromptOutput = process.stdout,
+): Promise<string> {
+	return await promptForMaskedValue("Telegram BotFather token: ", input, output);
+}
+
+async function promptForValue(label: string, masked: boolean): Promise<string> {
+	if (masked) return await promptForMaskedValue(label);
+	if (!process.stdin.isTTY) {
+		throw new Error("notify setup requires an interactive TTY unless all setup values are supplied as flags.");
+	}
+	const rl = createInterface({ input: process.stdin, output: process.stdout, terminal: true });
+	try {
+		return (await rl.question(label)).trim();
+	} finally {
+		rl.close();
+	}
+}
+
 function resolveSetupInteractive(deps: NotifyCommandDeps): boolean {
 	if (deps.setupInteractive !== undefined) return deps.setupInteractive;
 	return Boolean(process.stdin.isTTY) && !deps.setupChatId?.trim();

package/src/cli/session-picker.ts

@@ -1,13 +1,30 @@
+import * as path from "node:path";
 import { ProcessTerminal, TUI } from "@gajae-code/tui";
+import { pathIsWithin } from "@gajae-code/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.ts

@@ -9,7 +9,6 @@ import { Args, type CliConfig, Command, type CommandEntry, Flags, run } from "@g
 import { APP_NAME, formatBunRuntimeError, MIN_BUN_VERSION, VERSION } from "@gajae-code/utils/dirs";
 import { runFixtureReport } from "./cli/fixture-report";
 import { isTmuxOwnerIsolationCliArgv, runTmuxOwnerIsolationCliFromStdin } from "./gjc-runtime/tmux-owner-isolation-cli";
-import { runChatDaemonInternal } from "./sdk/bus/chat-daemon-cli";
 
 if (Bun.semver.order(Bun.version, MIN_BUN_VERSION) < 0) {
 	process.stderr.write(
@@ -134,6 +133,7 @@ async function runChatDaemonInternalFastPath(argv: string[]): Promise<void> {
 	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));
 }
 

package/src/commands/config.ts

@@ -5,7 +5,7 @@ import { Args, Command, Flags } from "@gajae-code/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";