@gajae-code/coding-agent 0.12.8 → 0.12.11

package/src/commands/sdk.ts

@@ -9,6 +9,7 @@ import { applyStartupModelProfiles, createSessionManager } from "../main";
 import { initializeExtensions } from "../modes/runtime-init";
 import { ACP_MCP_REQUEST_TIMEOUT_MS, ACP_MCP_STARTUP_HEADROOM_MS } from "../sdk/acp/mcp";
 import { Broker } from "../sdk/broker/broker";
+import { readBrokerDiscovery } from "../sdk/broker/discovery";
 import { completeBrokerProcess } from "../sdk/broker/internal";
 import {
 	type LifecycleTranscriptEvidence,
@@ -58,6 +59,54 @@ export async function lifecycleArgs(
 	};
 }
 
+/**
+ * How long a session host tolerates the complete absence of a live broker
+ * publication before treating itself as orphaned. Hosts intentionally survive
+ * broker restarts (a replacement broker republishes discovery within seconds),
+ * so this must comfortably exceed a restart window while still bounding the
+ * lifetime of hosts whose broker is gone for good — otherwise every crashed or
+ * torn-down broker leaks a detached multi-hundred-megabyte host forever.
+ */
+export const SESSION_HOST_BROKER_ABSENCE_GRACE_MS = 10 * 60_000;
+const SESSION_HOST_BROKER_POLL_MS = 15_000;
+
+/**
+ * Resolves only once no live broker publication has been observable in
+ * `agentDir` for the full grace window. A reappearing broker (including a
+ * replacement with a different pid) resets the window; an unreadable
+ * publication is not proof of orphanhood but accrues against the same bound.
+ */
+export async function watchSessionHostBrokerLiveness(deps: {
+	agentDir: string;
+	now?: () => number;
+	sleep?: (ms: number) => Promise<void>;
+	readDiscovery?: (agentDir: string) => Promise<unknown>;
+	graceMs?: number;
+	pollMs?: number;
+}): Promise<void> {
+	const now = deps.now ?? Date.now;
+	const sleep = deps.sleep ?? (async ms => await Bun.sleep(ms));
+	const readDiscovery = deps.readDiscovery ?? readBrokerDiscovery;
+	const graceMs = deps.graceMs ?? SESSION_HOST_BROKER_ABSENCE_GRACE_MS;
+	const pollMs = deps.pollMs ?? SESSION_HOST_BROKER_POLL_MS;
+	let absentSince: number | null = null;
+	for (;;) {
+		let live: unknown = null;
+		try {
+			live = await readDiscovery(deps.agentDir);
+		} catch {
+			// Transient read failures are ambiguity, not proof of orphanhood.
+		}
+		if (live) {
+			absentSince = null;
+		} else {
+			absentSince ??= now();
+			if (now() - absentSince >= graceMs) return;
+		}
+		await sleep(pollMs);
+	}
+}
+
 type LifecycleTranscriptSource = {
 	cwd: string;
 	path: string;
@@ -505,6 +554,11 @@ export async function runSessionHost(
 	}
 	process.once("SIGTERM", stop);
 	process.once("SIGINT", stop);
+	// A detached host whose broker is gone for good would otherwise live (and
+	// hold its session's memory) forever; reap it through the same graceful
+	// teardown a SIGTERM would take once the bounded absence grace elapses.
+	await watchSessionHostBrokerLiveness({ agentDir });
+	stop();
 	await new Promise<void>(() => {});
 }
 

package/src/config/model-profiles.ts

@@ -291,6 +291,13 @@ export const BUILTIN_MODEL_PROFILES: readonly ModelProfileDefinition[] = [
 		architect: "alibaba-token-plan/qwen3.8-max-preview:xhigh",
 		critic: "alibaba-token-plan/glm-5.2:high",
 	}),
+	profile("alibaba-token-plan-pro", ["alibaba-token-plan"], {
+		default: "alibaba-token-plan/qwen3.8-max-preview:medium",
+		executor: "alibaba-token-plan/deepseek-v4-flash-0731:max",
+		planner: "alibaba-token-plan/glm-5.2:high",
+		architect: "alibaba-token-plan/qwen3.8-max-preview:xhigh",
+		critic: "alibaba-token-plan/glm-5.2:xhigh",
+	}),
 	profile("alibaba-token-plan-qwenmaxxing", ["alibaba-token-plan"], {
 		default: "alibaba-token-plan/qwen3.8-max-preview:medium",
 		executor: "alibaba-token-plan/qwen3.8-max-preview:low",
@@ -361,6 +368,7 @@ const PROFILE_PRESENTATION: Record<string, ModelProfilePresentation> = {
 	"minimax-medium": { displayName: "MiniMax Medium", providerGroup: "MINIMAX" },
 	"minimax-pro": { displayName: "MiniMax Pro", providerGroup: "MINIMAX" },
 	"alibaba-token-plan-balanced": { displayName: "Balanced", providerGroup: "ALIBABA TOKEN PLAN" },
+	"alibaba-token-plan-pro": { displayName: "Pro", providerGroup: "ALIBABA TOKEN PLAN" },
 	"alibaba-token-plan-qwenmaxxing": { displayName: "QwenMaxxing", providerGroup: "ALIBABA TOKEN PLAN" },
 	"opus-codex": { displayName: "Opus + Codex", providerGroup: "COMBOS" },
 	"codex-opencodego": { displayName: "Codex + OpenCodeGo", providerGroup: "COMBOS" },

package/src/config/model-registry.ts

@@ -331,7 +331,10 @@ function validateProviderConfiguration(
 			throw new Error(
 				mode === "runtime-register"
 					? `Provider ${providerName}: "apiKey" or "oauth" is required when defining models.`
-					: `Provider ${providerName}: "apiKey" or "apiKeyEnv" is required when defining custom models unless auth is "none".`,
+					: `Provider ${providerName}: custom models need a credential source, but none is configured. ` +
+							`"auth" only selects the scheme ("auth: apiKey" does not supply a key). ` +
+							`Fix by adding "apiKeyEnv: <ENV_VAR>" (recommended) or "apiKey: <literal-key>", ` +
+							`or set "auth: none" if the endpoint is genuinely unauthenticated.`,
 			);
 		}
 	}

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/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];