@gajae-code/coding-agent 0.12.7 → 0.12.10

package/src/config/resolve-config-value.ts

@@ -16,22 +16,24 @@ const commandInFlight = new Map<string, Promise<string | undefined>>();
  * Resolve a config value (API key, header value, etc.) to an actual value.
  * - If starts with "!", executes the rest as a shell command and uses stdout (cached)
  * - Otherwise checks environment variable first, then treats as literal (not cached)
+ * - `cacheScope` isolates command-cache entries when a caller rotates its config
  */
-export async function resolveConfigValue(config: string): Promise<string | undefined> {
+export async function resolveConfigValue(config: string, cacheScope?: string): Promise<string | undefined> {
 	if (config.startsWith("!")) {
-		return await executeCommand(config);
+		return await executeCommand(config, cacheScope);
 	}
 	const envValue = process.env[config];
 	return envValue || config;
 }
 
-async function executeCommand(commandConfig: string): Promise<string | undefined> {
-	const cached = commandResultCache.get(commandConfig);
+async function executeCommand(commandConfig: string, cacheScope?: string): Promise<string | undefined> {
+	const cacheKey = cacheScope === undefined ? commandConfig : `${cacheScope}\u0000${commandConfig}`;
+	const cached = commandResultCache.get(cacheKey);
 	if (cached !== undefined) {
 		return cached;
 	}
 
-	const existing = commandInFlight.get(commandConfig);
+	const existing = commandInFlight.get(cacheKey);
 	if (existing) {
 		return await existing;
 	}
@@ -40,15 +42,15 @@ async function executeCommand(commandConfig: string): Promise<string | undefined
 	const promise = runShellCommand(command, 10_000)
 		.then(result => {
 			if (result !== undefined) {
-				commandResultCache.set(commandConfig, result);
+				commandResultCache.set(cacheKey, result);
 			}
 			return result;
 		})
 		.finally(() => {
-			commandInFlight.delete(commandConfig);
+			commandInFlight.delete(cacheKey);
 		});
 
-	commandInFlight.set(commandConfig, promise);
+	commandInFlight.set(cacheKey, promise);
 	return await promise;
 }
 

package/src/config/settings-schema.ts

@@ -149,7 +149,7 @@ export type AnyUiMetadata = UiBase & {
 
 interface BooleanDef {
 	type: "boolean";
-	default: boolean;
+	default?: boolean;
 	ui?: UiBoolean;
 }
 
@@ -285,6 +285,7 @@ export const SETTINGS_SCHEMA = {
 
 	// Notifications (shared daemon with Telegram/Discord/Slack presentation adapters)
 	"notifications.enabled": { type: "boolean", default: false },
+	"notifications.telegram.enabled": { type: "boolean" },
 	"notifications.telegram.botToken": {
 		type: "string",
 		default: undefined,
@@ -336,10 +337,12 @@ export const SETTINGS_SCHEMA = {
 		},
 	},
 	"notifications.telegram.topics.nameTemplate": { type: "string", default: undefined },
+	"notifications.discord.enabled": { type: "boolean" },
 	"notifications.discord.botToken": { type: "string", default: undefined },
 	"notifications.discord.applicationId": { type: "string", default: undefined },
 	"notifications.discord.guildId": { type: "string", default: undefined },
 	"notifications.discord.parentChannelId": { type: "string", default: undefined },
+	"notifications.slack.enabled": { type: "boolean" },
 	"notifications.slack.botToken": { type: "string", default: undefined },
 	"notifications.slack.appToken": { type: "string", default: undefined },
 	"notifications.slack.workspaceId": { type: "string", default: undefined },
@@ -3646,25 +3649,28 @@ type Schema = typeof SETTINGS_SCHEMA;
 export type SettingPath = keyof Schema;
 
 /** Infer the value type for a setting path */
-export type SettingValue<P extends SettingPath> = Schema[P] extends { type: "boolean" }
+export type SettingValue<P extends SettingPath> = Schema[P] extends { type: "boolean"; default: boolean }
 	? boolean
-	: Schema[P] extends { type: "string" }
-		? string | undefined
-		: Schema[P] extends { type: "number" }
-			? number
-			: Schema[P] extends { type: "enum"; values: infer V }
-				? V extends readonly string[]
-					? V[number]
-					: never
-				: Schema[P] extends { type: "array"; default: infer D }
-					? D
-					: Schema[P] extends { type: "record"; default: infer D }
+	: Schema[P] extends { type: "boolean" }
+		? boolean | undefined
+		: Schema[P] extends { type: "string" }
+			? string | undefined
+			: Schema[P] extends { type: "number" }
+				? number
+				: Schema[P] extends { type: "enum"; values: infer V }
+					? V extends readonly string[]
+						? V[number]
+						: never
+					: Schema[P] extends { type: "array"; default: infer D }
 						? D
-						: never;
+						: Schema[P] extends { type: "record"; default: infer D }
+							? D
+							: never;
 
 /** Get the default value for a setting path */
 export function getDefault<P extends SettingPath>(path: P): SettingValue<P> {
-	return SETTINGS_SCHEMA[path].default as SettingValue<P>;
+	const definition = SETTINGS_SCHEMA[path];
+	return ("default" in definition ? definition.default : undefined) as SettingValue<P>;
 }
 
 /** Check if a path has UI metadata (should appear in settings panel) */
@@ -3991,6 +3997,7 @@ export interface MemoryGuardSettings {
 export interface NotificationsSettings {
 	enabled: boolean;
 	telegram: {
+		enabled?: boolean;
 		botToken: string | undefined;
 		chatId: string | undefined;
 		sound: "all" | "important" | "none";
@@ -4014,16 +4021,19 @@ export interface NotificationsSettings {
 		};
 	};
 	discord: {
+		enabled?: boolean;
 		botToken: string | undefined;
 		applicationId: string | undefined;
 		guildId: string | undefined;
 		parentChannelId: string | undefined;
 	};
 	slack: {
+		enabled?: boolean;
 		botToken: string | undefined;
 		appToken: string | undefined;
 		workspaceId: string | undefined;
 		channelId: string | undefined;
+		authorizedUserId: string | undefined;
 	};
 	redact: boolean;
 	verbosity: "lean" | "verbose";

package/src/config/settings.ts

@@ -98,7 +98,7 @@ type DurableBatchRevision = {
 };
 type NotificationValidationState = {
 	malformedConfigRoot: boolean;
-	invalidNotificationConfiguration: boolean;
+	invalidNotificationGlobal: boolean;
 	generation: number;
 };
 type NotificationValidationRestoreGuard = {
@@ -378,7 +378,7 @@ export class Settings implements NotificationSettingsReader {
 	#hasMalformedConfigRoot = false;
 	/** YAML syntax was unrecoverable, so the loaded defaults are read-only until config.yml is repaired. */
 	#hasRecoveredConfigSyntax = false;
-	#hasInvalidNotificationConfiguration = false;
+	#hasInvalidNotificationGlobal = false;
 	#notificationValidationGeneration = 0;
 	/** Notification subtree fingerprint from the last raw durable config read. */
 	#durableNotificationFingerprint: string | undefined;
@@ -513,7 +513,7 @@ export class Settings implements NotificationSettingsReader {
 	 */
 	getNotificationSettingsSnapshot(): NotificationSettingsSnapshot {
 		return parseNotificationSettingsSnapshot(
-			this.#hasMalformedConfigRoot || this.#hasInvalidNotificationConfiguration ? null : this.#global,
+			this.#hasMalformedConfigRoot || this.#hasInvalidNotificationGlobal ? null : this.#rawNotificationConfig,
 		);
 	}
 
@@ -895,7 +895,7 @@ export class Settings implements NotificationSettingsReader {
 		cloned.#futureSchemaVersion = this.#futureSchemaVersion;
 		cloned.#hasMalformedConfigRoot = this.#hasMalformedConfigRoot;
 		cloned.#hasRecoveredConfigSyntax = this.#hasRecoveredConfigSyntax;
-		cloned.#hasInvalidNotificationConfiguration = this.#hasInvalidNotificationConfiguration;
+		cloned.#hasInvalidNotificationGlobal = this.#hasInvalidNotificationGlobal;
 		cloned.#notificationValidationGeneration = this.#notificationValidationGeneration;
 		cloned.#global = structuredClone(this.#global);
 		cloned.#rawNotificationConfig = structuredClone(this.#rawNotificationConfig);
@@ -1149,7 +1149,7 @@ export class Settings implements NotificationSettingsReader {
 	#resetYamlLoadState(): void {
 		this.#hasMalformedConfigRoot = false;
 		this.#hasRecoveredConfigSyntax = false;
-		this.#hasInvalidNotificationConfiguration = false;
+		this.#hasInvalidNotificationGlobal = false;
 		this.#schemaReport = { issues: [], valid: true };
 		this.#schemaMigrationPending = false;
 		this.#futureSchemaVersion = false;
@@ -1211,7 +1211,7 @@ export class Settings implements NotificationSettingsReader {
 				parseNotificationSettingsSnapshot(parsedRaw);
 			} catch (error) {
 				if (!(error instanceof Error) || error.message !== "gjc_notify_daemon_invalid_configuration") throw error;
-				this.#hasInvalidNotificationConfiguration = true;
+				this.#hasInvalidNotificationGlobal = true;
 			}
 		}
 		this.#futureSchemaVersion =
@@ -1875,7 +1875,7 @@ export class Settings implements NotificationSettingsReader {
 	#notificationValidationState(): NotificationValidationState {
 		return {
 			malformedConfigRoot: this.#hasMalformedConfigRoot,
-			invalidNotificationConfiguration: this.#hasInvalidNotificationConfiguration,
+			invalidNotificationGlobal: this.#hasInvalidNotificationGlobal,
 			generation: this.#notificationValidationGeneration,
 		};
 	}
@@ -1900,7 +1900,7 @@ export class Settings implements NotificationSettingsReader {
 	}
 	#restoreNotificationValidationState(state: NotificationValidationState): void {
 		this.#hasMalformedConfigRoot = state.malformedConfigRoot;
-		this.#hasInvalidNotificationConfiguration = state.invalidNotificationConfiguration;
+		this.#hasInvalidNotificationGlobal = state.invalidNotificationGlobal;
 	}
 	#rejectAtomicNotificationRepairForMalformedRoot(patches: readonly AtomicYamlPatch[], root: unknown): void {
 		if (
@@ -1951,17 +1951,17 @@ export class Settings implements NotificationSettingsReader {
 	#recomputeNotificationValidationFromRaw(): void {
 		if (this.#rawNotificationConfig === undefined) {
 			this.#hasMalformedConfigRoot = true;
-			this.#hasInvalidNotificationConfiguration = false;
+			this.#hasInvalidNotificationGlobal = false;
 			return;
 		}
 		try {
 			parseNotificationSettingsSnapshot(this.#rawNotificationConfig);
 			this.#hasMalformedConfigRoot = false;
-			this.#hasInvalidNotificationConfiguration = false;
+			this.#hasInvalidNotificationGlobal = false;
 		} catch (error) {
 			if (error instanceof Error && error.message === "gjc_notify_daemon_invalid_configuration") {
 				this.#hasMalformedConfigRoot = false;
-				this.#hasInvalidNotificationConfiguration = true;
+				this.#hasInvalidNotificationGlobal = true;
 				return;
 			}
 			throw error;
@@ -1973,10 +1973,10 @@ export class Settings implements NotificationSettingsReader {
 		try {
 			parseNotificationSettingsSnapshot(this.#rawNotificationConfig);
 			this.#hasMalformedConfigRoot = false;
-			this.#hasInvalidNotificationConfiguration = false;
+			this.#hasInvalidNotificationGlobal = false;
 		} catch (error) {
 			if (error instanceof Error && error.message === "gjc_notify_daemon_invalid_configuration") {
-				this.#hasInvalidNotificationConfiguration = true;
+				this.#hasInvalidNotificationGlobal = true;
 				return;
 			}
 			throw error;
@@ -2054,9 +2054,9 @@ export class Settings implements NotificationSettingsReader {
 // Setting Hooks
 // ═══════════════════════════════════════════════════════════════════════════
 
-type SettingHook<P extends SettingPath> = (value: SettingValue<P>, prev: SettingValue<P>) => void;
+type SettingHook = (value: unknown, prev: unknown) => void;
 
-const SETTING_HOOKS: Partial<Record<SettingPath, SettingHook<any>>> = {
+const SETTING_HOOKS: Partial<Record<SettingPath, SettingHook>> = {
 	"theme.dark": value => {
 		if (typeof value === "string") {
 			setAutoThemeMapping("dark", value);

package/src/discovery/agents-md.ts

@@ -5,56 +5,113 @@
  * This handles AGENTS.md files that live in project root (not in config directories
  * like .OpenAI code backend/ or .gemini/, which are handled by their respective providers).
  */
+import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import { registerProvider } from "../capability";
 import { type ContextFile, contextFileCapability } from "../capability/context-file";
-import { readFile } from "../capability/fs";
 import type { LoadContext, LoadResult } from "../capability/types";
 import { calculateDepth, createSourceMeta } from "./helpers";
 
 const PROVIDER_ID = "agents-md";
 const DISPLAY_NAME = "AGENTS.md";
+// Bound hostile ancestor walks and instruction payloads before they reach prompt assembly.
+const MAX_ANCESTOR_DIRECTORIES = 32;
+const MAX_FILE_BYTES = 64 * 1024;
+const MAX_AGGREGATE_BYTES = 256 * 1024;
+const DIRECTORY_LIMIT_WARNING = "AGENTS.md discovery stopped after scanning 32 ancestor directories.";
+const FILE_LIMIT_WARNING = "Skipped one or more AGENTS.md files that exceed the 64 KiB limit.";
+const AGGREGATE_LIMIT_WARNING = "Skipped one or more AGENTS.md files that exceed the 256 KiB aggregate limit.";
+
+export type AgentsMdReader = (
+	filePath: string,
+	maxBytes: number,
+) => Promise<{ content: string | null; byteLength: number; tooLarge: boolean }>;
+
+async function readBoundedAgentsMdFile(
+	filePath: string,
+	maxBytes: number,
+): Promise<{ content: string | null; byteLength: number; tooLarge: boolean }> {
+	try {
+		const file = await fs.open(filePath, fs.constants.O_RDONLY | fs.constants.O_NONBLOCK);
+		try {
+			const stats = await file.stat();
+			if (!stats.isFile()) return { content: null, byteLength: 0, tooLarge: false };
+			const bytes = Buffer.alloc(maxBytes + 1);
+			let bytesRead = 0;
+			while (bytesRead < bytes.length) {
+				const result = await file.read(bytes, bytesRead, bytes.length - bytesRead, bytesRead);
+				if (result.bytesRead === 0) break;
+				bytesRead += result.bytesRead;
+			}
+			if (bytesRead > maxBytes) return { content: null, byteLength: bytesRead, tooLarge: true };
+			return {
+				content: new TextDecoder().decode(bytes.subarray(0, bytesRead)),
+				byteLength: bytesRead,
+				tooLarge: false,
+			};
+		} finally {
+			await file.close();
+		}
+	} catch {
+		return { content: null, byteLength: 0, tooLarge: false };
+	}
+}
 
 /**
  * Load standalone AGENTS.md files.
  */
-async function loadAgentsMd(ctx: LoadContext): Promise<LoadResult<ContextFile>> {
+export async function loadAgentsMd(
+	ctx: LoadContext,
+	readCandidate: AgentsMdReader = readBoundedAgentsMdFile,
+): Promise<LoadResult<ContextFile>> {
 	const items: ContextFile[] = [];
 	const warnings: string[] = [];
-
-	// Walk up from cwd looking for AGENTS.md files
 	let current = ctx.cwd;
+	let scannedDirectories = 0;
+	let aggregateBytes = 0;
+	let omittedOversizedFile = false;
+	let omittedAggregateFile = false;
 
 	while (true) {
+		scannedDirectories += 1;
 		const candidate = path.join(current, "AGENTS.md");
-		const content = await readFile(candidate);
-
-		if (content !== null) {
-			const parent = path.dirname(candidate);
-			const baseName = parent.split(path.sep).pop() ?? "";
+		const parent = path.dirname(candidate);
+		const baseName = parent.split(path.sep).pop() ?? "";
 
-			if (!baseName.startsWith(".")) {
+		if (!baseName.startsWith(".")) {
+			const remainingAggregateBytes = MAX_AGGREGATE_BYTES - aggregateBytes;
+			const allowedBytes = Math.min(MAX_FILE_BYTES, remainingAggregateBytes);
+			const result = await readCandidate(candidate, allowedBytes);
+			if (result.tooLarge) {
+				if (allowedBytes < MAX_FILE_BYTES) omittedAggregateFile = true;
+				else omittedOversizedFile = true;
+			} else if (result.content !== null) {
 				const fileDir = path.dirname(candidate);
-				const calculatedDepth = calculateDepth(ctx.cwd, fileDir, path.sep);
-
 				items.push({
 					path: candidate,
-					content,
+					content: result.content,
 					level: "project",
-					depth: calculatedDepth,
+					depth: calculateDepth(ctx.cwd, fileDir, path.sep),
 					_source: createSourceMeta(PROVIDER_ID, candidate, "project"),
 				});
+				aggregateBytes += result.byteLength;
 			}
 		}
 
-		if (current === (ctx.repoRoot ?? ctx.home)) break; // scanned repo root or home, stop
+		const stopDirectory = ctx.repoRoot ?? ctx.home;
+		if (current === stopDirectory) break;
+		if (scannedDirectories === MAX_ANCESTOR_DIRECTORIES) {
+			warnings.push(DIRECTORY_LIMIT_WARNING);
+			break;
+		}
 
-		// Move to parent directory
-		const parent = path.dirname(current);
-		if (parent === current) break; // Reached filesystem root
-		current = parent;
+		const parentDirectory = path.dirname(current);
+		if (parentDirectory === current) break;
+		current = parentDirectory;
 	}
 
+	if (omittedOversizedFile) warnings.push(FILE_LIMIT_WARNING);
+	if (omittedAggregateFile) warnings.push(AGGREGATE_LIMIT_WARNING);
 	return { items, warnings };
 }
 

package/src/gjc-runtime/psmux-detect.ts

@@ -324,25 +324,21 @@ export function resolveGjcTmuxBinary(options: ResolveGjcTmuxBinaryOptions = {}):
 		return { command: explicit, isPsmux, viaExplicitOverride: true };
 	}
 	if (platform === "win32") {
-		const candidates: Array<{ command: string; identity: string }> = [];
-		for (const candidate of PSMUX_BINARY_NAMES) {
-			const executablePath = resolveBinaryPath(candidate);
+		for (const command of ["psmux", "pmux"] as const) {
+			const executablePath = resolveBinaryPath(command);
 			if (!executablePath) continue;
-			const isPsmuxAlias = candidate !== "tmux" || detectPsmuxForCommand(candidate, runner);
-			if (!isPsmuxAlias) continue;
-			const identity = activeExecutableIdentityResolver(executablePath);
-			if (!identity)
-				throw new Error(`gjc_tmux_provider_ambiguous: Windows ${candidate} executable identity is unavailable`);
-			candidates.push({ command: candidate, identity });
+			if (!activeExecutableIdentityResolver(executablePath))
+				throw new Error(`gjc_tmux_provider_ambiguous: Windows ${command} executable identity is unavailable`);
+			return { command, isPsmux: true, viaExplicitOverride: false };
 		}
-		if (candidates.length > 0) {
-			const identities = new Set(candidates.map(candidate => candidate.identity));
-			if (identities.size !== 1)
-				throw new Error("gjc_tmux_provider_ambiguous: Windows psmux aliases resolve to different executables");
-			// The order is the canonical provider spelling, then its compatibility
-			// aliases. Identity equality above makes PATH-order alias selection safe.
-			return { command: candidates[0]!.command, isPsmux: true, viaExplicitOverride: false };
+		const tmuxPath = resolveBinaryPath("tmux");
+		if (tmuxPath) {
+			const isPsmux = outputMentionsPsmux(probeVersionOutput(tmuxPath, runner));
+			if (isPsmux && !activeExecutableIdentityResolver(tmuxPath))
+				throw new Error("gjc_tmux_provider_ambiguous: Windows tmux executable identity is unavailable");
+			return { command: "tmux", isPsmux, viaExplicitOverride: false };
 		}
+		return { command: "tmux", isPsmux: false, viaExplicitOverride: false };
 	}
 	const tmuxPath = resolveBinaryPath("tmux");
 	if (tmuxPath) {

package/src/gjc-runtime/session-state-sidecar.ts

@@ -5,7 +5,7 @@ import * as path from "node:path";
 import type { AssistantMessage } from "@gajae-code/ai";
 import { normalizePathForComparison, postmortem } from "@gajae-code/utils";
 import { withFileLock } from "../config/file-lock";
-import { sessionRuntimeDir } from "./session-layout";
+import { sessionRoot, sessionRuntimeDir } from "./session-layout";
 import {
 	isValidOwnerIntent,
 	lifecyclePaths,
@@ -1022,6 +1022,7 @@ export async function persistCoordinatorRuntimeStateFromPostmortem(
 	const stateFile = runtimeStateFileForContext(context);
 	if (!stateFile) return;
 	const identity = normalizedIdentity(context);
+	const ownerSessionRoot = sessionRoot(context.cwd, identity.sessionId);
 	const ownerTerminalVerdict = context.ownerTerminal
 		? await observeOwnerTerminalPostmortem(reason, context.ownerTerminal, identity.sessionId)
 		: null;
@@ -1091,7 +1092,16 @@ export async function persistCoordinatorRuntimeStateFromPostmortem(
 						await writeStateFileSync(stateFile, payload);
 					}),
 			),
-	);
+	).catch(error => {
+		if ((error as NodeJS.ErrnoException).code === "ENOENT") {
+			try {
+				fsSync.lstatSync(ownerSessionRoot);
+			} catch (rootError) {
+				if ((rootError as NodeJS.ErrnoException).code === "ENOENT") return;
+			}
+		}
+		throw error;
+	});
 }
 
 export function registerCoordinatorRuntimeStateFinalizer(context: RuntimeStateContext): () => void {

package/src/gjc-runtime/tmux-sessions.ts

@@ -228,7 +228,7 @@ function runTmux(
 			);
 	}
 	if (result.exitCode === 0) return result.stdout?.toString() ?? "";
-	throw new Error(result.stderr?.toString().trim() || `tmux ${args.join(" ")} failed`);
+	throw new Error(result.stderr?.toString().trim() || `${tmuxCommand} ${args.join(" ")} failed`);
 }
 function normalizeExactTmuxTarget(sessionTarget: string, env: NodeJS.ProcessEnv, kind: "session" | "option"): string {
 	if (sessionTarget.startsWith("$")) return sessionTarget;
@@ -407,6 +407,13 @@ function psmuxAuthorityEnvironments(env: NodeJS.ProcessEnv): NodeJS.ProcessEnv[]
 			if (authorities.length > 0)
 				return authorities.map(authority => environmentForProviderAuthority(env, authority));
 		}
+		if (!ambient.viaExplicitOverride && !ambientAvailable) {
+			throw new Error(
+				"gjc_tmux_provider_unavailable — GJC searched for psmux, pmux, and tmux on PATH. " +
+					"Install psmux from https://github.com/psmux/psmux for native Windows support, use WSL with real tmux, " +
+					"or set GJC_TMUX_COMMAND (and GJC_PSMUX_COMMAND when selecting a psmux compatibility alias).",
+			);
+		}
 	}
 	if (ambient.isPsmux) throw new Error("gjc_tmux_provider_authority_unavailable");
 	return [env];