@gajae-code/coding-agent 0.11.11 → 0.12.1

package/src/commands/read.ts

@@ -1,7 +1,7 @@
 /**
  * Show what the read tool will return for a given path.
  */
-import { Args, Command } from "@gajae-code/utils/cli";
+import { Args, Command, Flags } from "@gajae-code/utils/cli";
 import { type ReadCommandArgs, runReadCommand } from "../cli/read-cli";
 import { initTheme } from "../modes/theme/theme";
 
@@ -15,8 +15,16 @@ export default class Read extends Command {
 		}),
 	};
 
+	static flags = {
+		truncation: Flags.string({
+			options: ["head", "last", "both"],
+			description: "Which end of an over-budget result to keep",
+		}),
+	};
+
 	static examples = [
 		"gjc read src/foo.ts",
+		"gjc read src/foo.ts --truncation head",
 		"gjc read src/foo.ts:50-100",
 		"gjc read src/foo.ts:raw",
 		"gjc read https://example.com",
@@ -25,9 +33,10 @@ export default class Read extends Command {
 	];
 
 	async run(): Promise<void> {
-		const { args } = await this.parse(Read);
+		const { args, flags } = await this.parse(Read);
 		const cmd: ReadCommandArgs = {
 			path: args.path ?? "",
+			truncation: flags.truncation as ReadCommandArgs["truncation"],
 		};
 		await initTheme();
 		await runReadCommand(cmd);

package/src/commands/team.ts

@@ -13,6 +13,7 @@ import {
 	readGjcTeamSnapshot,
 	shutdownGjcTeam,
 	startGjcTeam,
+	UnknownGjcTeamApiOperationError,
 } from "../gjc-runtime/team-runtime";
 import { syncSkillActiveState } from "../skill-state/active-state";
 
@@ -173,7 +174,7 @@ export default class Team extends Command {
 					"Supported operations:",
 					"send-message broadcast mailbox-list mailbox-mark-delivered mailbox-mark-notified notification-list notification-read notification-replay notification-mark-pane-attempt worker-startup-ack",
 					"create-task read-task list-tasks update-task claim-task transition-task-status release-task-claim",
-					"read-config read-manifest read-worker-status update-worker-status read-worker-heartbeat recover-stale-claims update-worker-heartbeat write-worker-inbox write-worker-identity",
+					"read-config read-manifest read-worker-status update-worker-status read-worker-heartbeat recover-stale-claims update-worker-heartbeat read-worker-memory-guard update-worker-memory-guard apply-worker-memory-guard write-worker-inbox write-worker-identity",
 					"append-event read-events read-traces await-event write-shutdown-request read-shutdown-ack read-monitor-snapshot write-monitor-snapshot read-task-approval write-task-approval",
 					"Completion example:",
 					'transition-task-status --input \'{"team_name":"demo","task_id":"task-1","to":"completed","claim_token":"...","completion_evidence":{"summary":"done","items":[{"kind":"command","status":"passed","summary":"focused tests passed","command":"bun test packages/coding-agent/test/gjc-runtime/team-runtime.test.ts"}]}}\' --json',
@@ -183,7 +184,24 @@ export default class Team extends Command {
 				return;
 			}
 			const input = parseInputFlag(rest);
-			const result = await executeGjcTeamApiOperation(operation, input);
+			let result: unknown;
+			try {
+				result = await executeGjcTeamApiOperation(operation, input);
+			} catch (error) {
+				if (!(error instanceof UnknownGjcTeamApiOperationError)) throw error;
+				process.exitCode = 1;
+				if (json) {
+					writeReceipt({
+						ok: false,
+						error: error.code,
+						operation: error.operation,
+						suggestions: error.suggestions,
+					});
+				} else {
+					process.stderr.write(`${error.message}\n`);
+				}
+				return;
+			}
 			const teamName = String(input.team_name ?? input.teamName ?? "").trim();
 			if (teamName) {
 				try {

package/src/config/file-lock.ts

@@ -1,7 +1,7 @@
 import type { Stats } from "node:fs";
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
-import { isEnoent } from "@gajae-code/utils/fs-error";
+import { hasFsCode, isEnoent } from "@gajae-code/utils/fs-error";
 
 export interface FileLockOptions {
 	staleMs?: number;
@@ -185,7 +185,16 @@ async function staleLockSnapshot(
 	staleMs: number,
 	startTimeCache?: Map<string, string | null>,
 ): Promise<LockStaleSnapshot> {
-	const info = await readLockInfo(lockPath);
+	let info: LockInfo | null;
+	try {
+		info = await readLockInfo(lockPath);
+	} catch (error) {
+		// Windows can transiently deny reads of a just-created lock metadata file
+		// while another contender is publishing it. Treat that as active
+		// contention and retry rather than failing the caller or reaping by path.
+		if (hasFsCode(error, "EPERM")) return { stale: false };
+		throw error;
+	}
 	if (!info) {
 		try {
 			const stats = await fs.stat(lockPath);

package/src/config/model-registry.ts

@@ -34,7 +34,7 @@ const DEFAULT_LOCAL_TOKEN = "lm-studio-local";
 
 import { registerOAuthProvider, unregisterOAuthProviders } from "@gajae-code/ai/utils/oauth";
 import type { OAuthCredentials, OAuthLoginCallbacks } from "@gajae-code/ai/utils/oauth/types";
-import { $pickenv, isRecord, logger } from "@gajae-code/utils";
+import { $pickCredentialEnv, isRecord, logger } from "@gajae-code/utils";
 import { parseModelString, resolveProviderModelReference } from "../config/model-resolver";
 import { isValidThemeColor, type ThemeColor } from "../modes/theme/theme";
 import type { AuthStorage, OAuthCredential } from "../session/auth-storage";
@@ -450,8 +450,20 @@ function getProviderBaseUrlEnvKeys(provider: string): string[] {
 	return keys;
 }
 
+/**
+ * Provider base URL from the environment, trusted sources only.
+ *
+ * The result is baked into the provider override and reaches `model.baseUrl`,
+ * which the provider resolvers use as the request endpoint that carries the
+ * provider credential. `$env` (and therefore `$pickenv`) merges the caller's
+ * `cwd/.env`, so reading it there would let repository content redirect
+ * authenticated traffic for any provider — including re-admitting a redirect
+ * that the provider-level resolvers already reject. Resolve it the same way
+ * provider credentials are: launching shell plus GJC/user-owned `.env` files,
+ * never the project `.env`.
+ */
 function resolveProviderBaseUrlFromEnv(provider: string): string | undefined {
-	return $pickenv(...getProviderBaseUrlEnvKeys(provider));
+	return $pickCredentialEnv(...getProviderBaseUrlEnvKeys(provider));
 }
 
 function normalizeLocalOpenAICompatBaseUrl(baseUrl: string): string {
@@ -2507,6 +2519,13 @@ export class ModelRegistry {
 		return this.#keylessProviders.has(model.provider) || this.authStorage.hasAuth(model.provider);
 	}
 
+	/**
+	 * Check whether auth is configured for a provider.
+	 */
+	hasConfiguredProviderAuth(provider: string): boolean {
+		return this.#keylessProviders.has(provider) || this.authStorage.hasAuth(provider);
+	}
+
 	getDiscoverableProviders(): string[] {
 		const disabledProviders = getDisabledProviderIdsFromSettings();
 		return this.#discoveryManager.providers

package/src/config/provider-auth-health.ts

@@ -0,0 +1,42 @@
+import type { AuthStorage } from "@gajae-code/ai/auth-storage";
+
+/**
+ * Most recent OAuth validation outcome per provider, used only as an ordering
+ * hint so `/model` can rank a provider whose stored credentials failed
+ * validation below one that is healthy, without re-running validation itself.
+ *
+ * Entries are scoped to the `AuthStorage` that produced them and to its
+ * credential generation, so any login, logout, import, or deletion discards the
+ * stale result instead of overriding current auth state.
+ */
+export type ProviderAuthHealth = "valid" | "invalid";
+
+interface HealthEntry {
+	generation: number;
+	health: ProviderAuthHealth;
+}
+
+const healthByStorage = new WeakMap<AuthStorage, Map<string, HealthEntry>>();
+
+export function recordProviderAuthHealth(
+	authStorage: AuthStorage,
+	providerId: string,
+	health: ProviderAuthHealth,
+): void {
+	let entries = healthByStorage.get(authStorage);
+	if (!entries) {
+		entries = new Map();
+		healthByStorage.set(authStorage, entries);
+	}
+	entries.set(providerId, { generation: authStorage.getGeneration(), health });
+}
+
+export function getProviderAuthHealth(authStorage: AuthStorage, providerId: string): ProviderAuthHealth | undefined {
+	const entry = healthByStorage.get(authStorage)?.get(providerId);
+	if (!entry || entry.generation !== authStorage.getGeneration()) return undefined;
+	return entry.health;
+}
+
+export function clearProviderAuthHealth(authStorage: AuthStorage): void {
+	healthByStorage.delete(authStorage);
+}

package/src/config/provider-ranking.ts

@@ -0,0 +1,119 @@
+/**
+ * Shared provider ordering used by every provider-facing selector (`/login`,
+ * `/model`, `/provider`).
+ *
+ * Providers the user already has come first, then a curated list of well-known
+ * providers, then everything else alphabetically. This is the single source of
+ * truth for that order — surfaces must not keep their own famous-provider list.
+ */
+
+/**
+ * Auth/config state of a provider as seen by the calling surface.
+ *
+ * - `valid` — stored credentials that validated successfully.
+ * - `checking` — stored credentials whose async validation is still in flight.
+ *   Ranked with `valid` so rows do not reflow when validation resolves.
+ * - `configured` — no OAuth record, but the provider is present in the model
+ *   registry with a working API key (custom/API-compatible providers).
+ * - `invalid` — stored credentials that failed validation (problematic login).
+ * - `none` — nothing stored and nothing configured.
+ */
+export type ProviderAuthState = "valid" | "checking" | "configured" | "invalid" | "none";
+
+export const PROVIDER_RANK_TIER = {
+	existing: 0,
+	problematic: 1,
+	famous: 2,
+	other: 3,
+} as const;
+
+export type ProviderRankTier = (typeof PROVIDER_RANK_TIER)[keyof typeof PROVIDER_RANK_TIER];
+
+/**
+ * Curated provider order for the famous tier. Regional and device variants sit
+ * immediately behind their primary so related entries stay grouped.
+ */
+export const FAMOUS_PROVIDER_ORDER: readonly string[] = [
+	"openai-codex",
+	"openai-codex-device",
+	"anthropic",
+	"xai",
+	"opencode-go",
+	"zai",
+	"glm-zcode",
+	"alibaba-token-plan",
+	"qwen-portal",
+	"kimi-code",
+	"moonshot",
+	"minimax-code",
+	"minimax-code-cn",
+	"xiaomi",
+	"xiaomi-token-plan-sgp",
+	"xiaomi-token-plan-ams",
+	"xiaomi-token-plan-cn",
+	"opengateway",
+	"bizrouter",
+	"github-copilot",
+	"cursor",
+];
+
+const FAMOUS_PROVIDER_INDEX = new Map(FAMOUS_PROVIDER_ORDER.map((id, index) => [id, index]));
+
+/** A provider as ranked by a surface. `label` is what the user sees. */
+export interface RankableProvider {
+	id: string;
+	label: string;
+	authState: ProviderAuthState;
+}
+
+/** A provider's position in the ordering: its tier plus its rank inside that tier. */
+export interface ProviderRank {
+	tier: ProviderRankTier;
+	intraTierRank: number;
+}
+
+/**
+ * The single ranking result for a provider. `intraTierRank` is the curated
+ * famous-list position, or `Number.MAX_SAFE_INTEGER` for providers that are not
+ * on the list and therefore order by display label.
+ */
+export function rankProvider(provider: RankableProvider): ProviderRank {
+	return {
+		tier: providerRankTier(provider.authState, provider.id),
+		intraTierRank: FAMOUS_PROVIDER_INDEX.get(provider.id) ?? Number.MAX_SAFE_INTEGER,
+	};
+}
+
+export function providerRankTier(authState: ProviderAuthState, id: string): ProviderRankTier {
+	if (authState === "valid" || authState === "checking" || authState === "configured") {
+		return PROVIDER_RANK_TIER.existing;
+	}
+	if (authState === "invalid") return PROVIDER_RANK_TIER.problematic;
+	return FAMOUS_PROVIDER_INDEX.has(id) ? PROVIDER_RANK_TIER.famous : PROVIDER_RANK_TIER.other;
+}
+
+/** Position within the famous list, or `undefined` for providers not on it. */
+export function famousProviderIndex(id: string): number | undefined {
+	return FAMOUS_PROVIDER_INDEX.get(id);
+}
+
+/**
+ * Total order over providers: tier, then famous-list position, then display
+ * label, then id. The trailing id comparison guarantees no ties.
+ */
+export function compareRankedProviders(left: RankableProvider, right: RankableProvider): number {
+	const leftRank = rankProvider(left);
+	const rightRank = rankProvider(right);
+	if (leftRank.tier !== rightRank.tier) return leftRank.tier - rightRank.tier;
+	if (leftRank.intraTierRank !== rightRank.intraTierRank) return leftRank.intraTierRank - rightRank.intraTierRank;
+
+	const label = left.label.localeCompare(right.label);
+	if (label !== 0) return label;
+
+	return left.id.localeCompare(right.id);
+}
+
+/** Convenience wrapper returning a new array in ranked order. */
+export function sortRankedProviders<T extends RankableProvider>(providers: readonly T[]): T[] {
+	return [...providers].sort(compareRankedProviders);
+}

package/src/config/settings-schema.ts

@@ -275,6 +275,13 @@ export const SETTINGS_SCHEMA = {
 		values: ["copy-retain", "disabled"] as const,
 		default: "copy-retain",
 	},
+	// SDK-owned prompt deadline. Hidden from the UI; ACP has no separate timeout.
+	"sdk.promptDeadlineMs": {
+		type: "number",
+		default: 1_800_000,
+		description: "SDK-owned prompt deadline; ACP has no separate timeout.",
+		validate: (value: number) => Number.isSafeInteger(value) && value >= 60_000 && value <= 86_400_000,
+	},
 
 	// Notifications (shared daemon with Telegram/Discord/Slack presentation adapters)
 	"notifications.enabled": { type: "boolean", default: false },
@@ -287,6 +294,17 @@ export const SETTINGS_SCHEMA = {
 	"notifications.telegram.activation": { type: "record", default: {} as Record<string, unknown> },
 	"notifications.telegram.btw.enabled": { type: "boolean", default: true },
 	"notifications.telegram.streaming.enabled": { type: "boolean", default: true },
+	"notifications.telegram.sound": {
+		type: "enum",
+		values: ["all", "important", "none"] as const,
+		default: "all",
+		ui: {
+			tab: "notifications",
+			label: "Telegram Notification Sounds",
+			description: "Choose which Telegram notifications play a sound.",
+			editing: "notification-atomic",
+		},
+	},
 	"notifications.telegram.rich.enabled": {
 		type: "boolean",
 		default: true,
@@ -489,6 +507,22 @@ export const SETTINGS_SCHEMA = {
 			options: "runtime",
 		},
 	},
+	"session.resumeModelBehavior": {
+		type: "enum",
+		values: ["keepSessionModel", "useCurrentDefault", "ask"] as const,
+		default: "keepSessionModel",
+		ui: {
+			tab: "model",
+			label: "Resume Model Behavior",
+			description:
+				"When resuming a session: keep the model that session last used, switch to the currently configured default model, or ask (TUI only; falls back to keeping the session's model in headless/CLI resume).",
+			options: [
+				{ value: "keepSessionModel", label: "Keep session's saved model" },
+				{ value: "useCurrentDefault", label: "Use current default model" },
+				{ value: "ask", label: "Ask on resume (TUI only)" },
+			],
+		},
+	},
 
 	modelTags: { type: "record", default: EMPTY_MODEL_TAGS_RECORD },
 
@@ -501,11 +535,21 @@ export const SETTINGS_SCHEMA = {
 		default: 0.05,
 		validate: (value: number) => Number.isFinite(value) && value > 0 && value <= 1,
 	},
+	"gjc.ralplan.autoHandoff": {
+		type: "enum",
+		values: ["off", "ultragoal", "team"],
+		default: "off",
+	},
 	"gjc.ralplan.maxIterations": {
 		type: "number",
 		default: 5,
 		validate: (value: number) => Number.isInteger(value) && value >= 1 && value <= 20,
 	},
+	"gjc.ralplan.maxReviewPassesPerLane": {
+		type: "number",
+		default: 1,
+		validate: (value: number) => Number.isInteger(value) && value >= 1 && value <= 10,
+	},
 
 	// ────────────────────────────────────────────────────────────────────────
 	// Appearance
@@ -1219,6 +1263,16 @@ export const SETTINGS_SCHEMA = {
 				"Maximum provider stream replay retries for replay-safe transient stream failures. Counts retries, not the first attempt. Set to 0 to disable provider stream retries.",
 		},
 	},
+	"retry.streamFirstEventTimeoutMs": {
+		type: "number",
+		default: 100_000,
+		validate: (value: number) => Number.isFinite(value) && value >= 0,
+		ui: {
+			tab: "model",
+			label: "First Event Timeout",
+			description: "Maximum wait for the first provider stream event, in ms. Set to 0 to disable the watchdog.",
+		},
+	},
 	"retry.fallbackChains": { type: "record", default: {} as Record<string, string[]> },
 	"retry.fallbackRevertPolicy": {
 		type: "enum",
@@ -2054,7 +2108,8 @@ export const SETTINGS_SCHEMA = {
 		ui: {
 			tab: "editing",
 			label: "Default Read Limit",
-			description: "Default number of lines returned when agent calls read without a limit",
+			description:
+				"Default collection/selection limit for read operations; bare local receipts use the separate 50-line / 10 KiB receipt budgets",
 			options: [
 				{ value: "200", label: "200 lines" },
 				{ value: "300", label: "300 lines" },
@@ -2094,6 +2149,22 @@ export const SETTINGS_SCHEMA = {
 			],
 		},
 	},
+	"read.truncation": {
+		type: "enum",
+		values: ["head", "last", "both"] as const,
+		default: "last",
+		ui: {
+			tab: "editing",
+			label: "Read Truncation",
+			description:
+				"Configured default direction for routes that support directional truncation; bare local and archive reads use this value (factory default: last), while explicit truncation always wins",
+			options: [
+				{ value: "head", label: "Head", description: "Keep the first N lines" },
+				{ value: "last", label: "Last", description: "Keep the last N lines (default)" },
+				{ value: "both", label: "Both", description: "Keep the start and the end, elide the middle" },
+			],
+		},
+	},
 	"read.summaryMaxBytes": {
 		type: "number",
 		default: 20,
@@ -3788,6 +3859,7 @@ export interface RetrySettings {
 	maxDelayMs: number;
 	requestMaxRetries: number;
 	streamMaxRetries: number;
+	streamFirstEventTimeoutMs: number;
 }
 
 export interface MemoriesSettings {
@@ -3907,6 +3979,7 @@ export interface NotificationsSettings {
 	telegram: {
 		botToken: string | undefined;
 		chatId: string | undefined;
+		sound: "all" | "important" | "none";
 		btw: {
 			enabled: boolean;
 		};