@gajae-code/coding-agent 0.11.11 → 0.12.1

package/src/setup/credential-import.ts

@@ -7,16 +7,17 @@
  * {@link AuthCredential} payloads that go straight into the store.
  *
  * Sources:
- *   - Claude Code: `~/.claude/.credentials.json` (Linux/WSL/Windows native),
- *     the macOS Keychain (`Claude Code-credentials`), and env vars.
- *   - Codex CLI: `~/.codex/auth.json` (OAuth `tokens` block or stored
- *     `OPENAI_API_KEY`), and env vars.
+ *   - Claude Code: `$CLAUDE_CONFIG_DIR/.credentials.json` (defaults to
+ *     `~/.claude/.credentials.json`) on Linux/WSL/Windows native, the macOS
+ *     Keychain (`Claude Code-credentials`), and env vars.
+ *   - Codex CLI: `$CODEX_HOME/auth.json` (defaults to `~/.codex/auth.json`;
+ *     OAuth `tokens` block or stored `OPENAI_API_KEY`), and env vars.
  */
 import * as fs from "node:fs/promises";
 import * as os from "node:os";
 import * as path from "node:path";
 import type { AuthCredential, OAuthCredential } from "@gajae-code/ai";
-import { isEnoent } from "@gajae-code/utils";
+import { $credentialEnv, isEnoent } from "@gajae-code/utils";
 import { redactSecret } from "./provider-onboarding";
 
 /** gjc provider ids that external credentials map onto. */
@@ -79,6 +80,18 @@ export interface DiscoveryOptions {
 	env?: Record<string, string | undefined>;
 	/** Override the platform (defaults to `process.platform`). */
 	platform?: NodeJS.Platform;
+	/**
+	 * Claude Code config directory holding `.credentials.json`.
+	 *
+	 * Defaults to the trusted `CLAUDE_CONFIG_DIR` value, else `<homeDir>/.claude`.
+	 */
+	claudeConfigDir?: string;
+	/**
+	 * Codex CLI home directory holding `auth.json`.
+	 *
+	 * Defaults to the trusted `CODEX_HOME` value, else `<homeDir>/.codex`.
+	 */
+	codexHome?: string;
 	/**
 	 * Reader for the macOS Keychain `Claude Code-credentials` entry. Defaults to
 	 * shelling out to `security`; injected in tests. Returns the raw JSON string,
@@ -206,12 +219,24 @@ function parseClaudeCredentials(
 	};
 }
 
+/**
+ * A discovery root plus the leak-free label used in redacted summaries.
+ *
+ * `display` never contains a resolved filesystem path: it is either the
+ * home-relative default or the env-var spelling that redirected the lookup.
+ */
+interface ResolvedExternalDir {
+	dir: string;
+	display: string;
+}
+
 async function discoverClaudeCode(
-	opts: Required<Pick<DiscoveryOptions, "homeDir" | "platform">> & Pick<DiscoveryOptions, "readClaudeKeychain">,
+	opts: Required<Pick<DiscoveryOptions, "platform">> &
+		Pick<DiscoveryOptions, "readClaudeKeychain"> & { configDir: ResolvedExternalDir },
 	result: CredentialDiscoveryResult,
 ): Promise<void> {
-	const filePath = path.join(opts.homeDir, ".claude", ".credentials.json");
-	const displayPath = `~/.claude/.credentials.json`;
+	const filePath = path.join(opts.configDir.dir, ".credentials.json");
+	const displayPath = `${opts.configDir.display}/.credentials.json`;
 	let fileRaw: string | null = null;
 	try {
 		fileRaw = await fs.readFile(filePath, "utf-8");
@@ -324,9 +349,9 @@ function parseCodexAuth(raw: string, source: string): ImportableCredential | Ski
 	return { origin: "codex-file", source, reason: "no OAuth tokens or OPENAI_API_KEY present (unsupported shape)" };
 }
 
-async function discoverCodex(homeDir: string, result: CredentialDiscoveryResult): Promise<void> {
-	const filePath = path.join(homeDir, ".codex", "auth.json");
-	const displayPath = "~/.codex/auth.json";
+async function discoverCodex(home: ResolvedExternalDir, result: CredentialDiscoveryResult): Promise<void> {
+	const filePath = path.join(home.dir, "auth.json");
+	const displayPath = `${home.display}/auth.json`;
 	let raw: string | null = null;
 	try {
 		raw = await fs.readFile(filePath, "utf-8");
@@ -367,6 +392,34 @@ function pushOutcome(result: CredentialDiscoveryResult, outcome: ImportableCrede
 	else result.importable.push(outcome);
 }
 
+/**
+ * Resolve a discovery root that the external CLI itself relocates through the
+ * environment (`CLAUDE_CONFIG_DIR`, `CODEX_HOME`).
+ *
+ * Both variables are read through `$credentialEnv`, so the caller's project
+ * `.env` cannot redirect discovery at a credential file a repository ships —
+ * the same boundary provider authentication already uses.
+ *
+ * Relative values are rejected. Claude Code and Codex resolve them against the
+ * process cwd, which for gjc is the user's project directory; honouring that
+ * would reintroduce the project-controlled redirect the trust boundary exists
+ * to prevent. An explicit `options.env` (tests, embedders) is consulted verbatim
+ * instead of the ambient environment.
+ */
+function resolveExternalDir(
+	name: "CLAUDE_CONFIG_DIR" | "CODEX_HOME",
+	envOverride: Record<string, string | undefined> | undefined,
+	fallbackDir: string,
+	fallbackDisplay: string,
+): ResolvedExternalDir {
+	const raw = envOverride ? envOverride[name] : $credentialEnv(name);
+	const trimmed = raw?.trim();
+	if (trimmed && path.isAbsolute(trimmed)) {
+		return { dir: trimmed, display: `$${name}` };
+	}
+	return { dir: fallbackDir, display: fallbackDisplay };
+}
+
 /**
  * Discover Claude Code and Codex CLI credentials across files, the macOS
  * Keychain, and environment variables. Never throws for individual unreadable or
@@ -376,9 +429,18 @@ export async function discoverExternalCredentials(options: DiscoveryOptions = {}
 	const homeDir = options.homeDir ?? os.homedir();
 	const env = options.env ?? process.env;
 	const platform = options.platform ?? process.platform;
+	const claudeConfigDir: ResolvedExternalDir = options.claudeConfigDir
+		? { dir: options.claudeConfigDir, display: "$CLAUDE_CONFIG_DIR" }
+		: resolveExternalDir("CLAUDE_CONFIG_DIR", options.env, path.join(homeDir, ".claude"), "~/.claude");
+	const codexHome: ResolvedExternalDir = options.codexHome
+		? { dir: options.codexHome, display: "$CODEX_HOME" }
+		: resolveExternalDir("CODEX_HOME", options.env, path.join(homeDir, ".codex"), "~/.codex");
 	const result: CredentialDiscoveryResult = { importable: [], skipped: [], environment: [] };
-	await discoverClaudeCode({ homeDir, platform, readClaudeKeychain: options.readClaudeKeychain }, result);
-	await discoverCodex(homeDir, result);
+	await discoverClaudeCode(
+		{ configDir: claudeConfigDir, platform, readClaudeKeychain: options.readClaudeKeychain },
+		result,
+	);
+	await discoverCodex(codexHome, result);
 	discoverEnvironment(env, result);
 	return result;
 }

package/src/setup/provider-onboarding.ts

@@ -4,6 +4,7 @@ import * as path from "node:path";
 import { getAgentDbPath, getAgentDir } from "@gajae-code/utils";
 import { YAML } from "bun";
 import { type ModelsConfig, ModelsConfigSchema } from "../config/models-config-schema";
+import { compareRankedProviders, famousProviderIndex } from "../config/provider-ranking";
 import { AuthStorage } from "../session/auth-storage";
 import providerPresets from "./provider-presets.json";
 
@@ -81,11 +82,25 @@ export function findProviderPreset(value: string | undefined): ProviderPreset |
 	return PROVIDER_PRESETS.find(preset => preset.id === normalized || preset.aliases.includes(normalized));
 }
 
+function providerPresetRankingId(preset: ProviderPreset): string {
+	return (
+		[preset.providerId, preset.id, ...preset.aliases].find(id => famousProviderIndex(id) !== undefined) ?? preset.id
+	);
+}
+
 export function formatProviderPresetList(): string {
-	return PROVIDER_PRESETS.map(preset => {
-		const aliases = preset.aliases.length > 0 ? ` (aliases: ${preset.aliases.join(", ")})` : "";
-		return `${preset.id}${aliases}: ${preset.description}`;
-	}).join("\n");
+	return [...PROVIDER_PRESETS]
+		.sort((left, right) =>
+			compareRankedProviders(
+				{ id: providerPresetRankingId(left), label: left.name, authState: "none" },
+				{ id: providerPresetRankingId(right), label: right.name, authState: "none" },
+			),
+		)
+		.map(preset => {
+			const aliases = preset.aliases.length > 0 ? ` (aliases: ${preset.aliases.join(", ")})` : "";
+			return `${preset.id}${aliases}: ${preset.description}`;
+		})
+		.join("\n");
 }
 
 export function parseModelList(values: readonly string[]): string[] {

package/src/skill-state/active-state.ts

@@ -71,8 +71,6 @@ export interface SkillActiveEntry {
 	handoff_at?: string;
 	active_subskills?: ActiveSubskillEntry[];
 	source_state_revision?: number;
-	/** Durable ordering token from the source workflow mode-state, not this cache file's revision. */
-	committed_mode_state_revision?: number;
 }
 
 export interface SkillActiveState {
@@ -116,8 +114,6 @@ export interface SyncSkillActiveStateOptions {
 	handoff_at?: string;
 	active_subskills?: ActiveSubskillEntry[];
 	sourceRevision?: number;
-	/** Durable ordering token from the source workflow mode-state, not this cache file's revision. */
-	committedModeRevision?: number;
 }
 
 const HUD_TEXT_LIMIT = 80;
@@ -306,6 +302,32 @@ export function isCanonicalGjcWorkflowSkill(skill: string): skill is CanonicalGj
 	return (CANONICAL_GJC_WORKFLOW_SKILLS as readonly string[]).includes(skill);
 }
 
+/**
+ * Nonterminal phases that intentionally await workflow-specific integration
+ * rather than a generic synthetic compaction continuation.
+ */
+const CONTINUATION_INERT_WORKFLOW_PHASES: Readonly<Partial<Record<CanonicalGjcWorkflowSkill, ReadonlySet<string>>>> = {
+	team: new Set(["awaiting_integration"]),
+};
+
+/**
+ * Continuation inertness for compaction auto-continue, derived from each
+ * workflow's manifest contract: manifest-terminal and explicitly inert phases
+ * are inert; unknown skills or phases unknown to the skill's manifest are
+ * conservatively inert so a synthetic continuation never wakes an unrecognized
+ * workflow. Generic Ultragoal `blocked` remains continuation-active because its
+ * blocker may be autonomously resolvable; verified human pauses are represented
+ * by the inline goal's `paused` status instead.
+ */
+export function isWorkflowContinuationInert(skill: string, phase: string): boolean {
+	const normalizedPhase = phase.trim().toLowerCase();
+	if (!isCanonicalGjcWorkflowSkill(skill)) return true;
+	const manifest = getSkillManifest(skill);
+	if (manifest.terminalStates.some(terminal => terminal.toLowerCase() === normalizedPhase)) return true;
+	if (CONTINUATION_INERT_WORKFLOW_PHASES[skill]?.has(normalizedPhase)) return true;
+	return !manifest.states.some(state => state.id.toLowerCase() === normalizedPhase);
+}
+
 export function listActiveSkills(raw: unknown): SkillActiveEntry[] {
 	if (!raw || typeof raw !== "object") return [];
 	const state = raw as SkillActiveState;
@@ -619,6 +641,8 @@ async function mergeVisibleEntries(
 export type VisibleSkillActiveStateCacheTier = "security" | "hud";
 export interface ReadVisibleSkillActiveStateOptions {
 	tier?: VisibleSkillActiveStateCacheTier;
+	/** Bypass all signature/TTL caches for authorization decisions. */
+	bypassCache?: boolean;
 }
 
 interface ActiveStateStatSignature {
@@ -751,6 +775,10 @@ export async function readVisibleSkillActiveState(
 	}
 	const resolvedCwd = path.resolve(cwd);
 	const cacheKey = visibleActiveStateCacheKey(resolvedCwd, resolvedSessionId);
+	if (opts?.bypassCache) {
+		visibleSkillActiveStateCache.delete(cacheKey);
+		return await readVisibleSkillActiveStateUncached(resolvedCwd, resolvedSessionId);
+	}
 	const tier = opts?.tier ?? "security";
 	const now = Date.now();
 	const cached = visibleSkillActiveStateCache.get(cacheKey);
@@ -789,9 +817,6 @@ async function persistActiveEntry(
 		await writeActiveEntry(cwd, sessionScope, entry.skill, entry, {
 			cwd,
 			audit: activeStateWriterAudit("write-active-entry", sessionScope),
-			...(typeof entry.committed_mode_state_revision === "number"
-				? { orderingRevision: entry.committed_mode_state_revision }
-				: {}),
 		});
 	}
 }
@@ -870,9 +895,6 @@ export async function syncSkillActiveState(options: SyncSkillActiveStateOptions)
 				? { active_subskills: preservedActiveSubskills }
 				: {}),
 		...(typeof options.sourceRevision === "number" ? { source_state_revision: options.sourceRevision } : {}),
-		...(typeof options.committedModeRevision === "number"
-			? { committed_mode_state_revision: options.committedModeRevision }
-			: {}),
 	};
 	const sessionScope = { sessionId: options.sessionId };
 	await removeSupersededPlanningPipelineEntries(options.cwd, sessionScope, entry);

package/src/skill-state/workflow-hud.ts

@@ -23,9 +23,18 @@ interface RalplanHudState extends WorkflowGateHudState {
 	iteration?: number;
 	iterationFromIndex?: number;
 	stages?: string;
+	architectPasses?: number;
+	criticPasses?: number;
+	reviewPassBudget?: number;
 	verdict?: string;
 	latestSummary?: string;
 	pendingApproval?: boolean;
+	autoHandoff?: {
+		configuredTarget: string;
+		effectiveTarget: string;
+		degradationReason: string | null;
+	};
+	planningStuck?: boolean;
 	updatedAt?: string;
 }
 
@@ -194,13 +203,41 @@ export function deriveDeepInterviewHud(
 export function buildRalplanHudSummary(state: RalplanHudState): WorkflowHudSummary {
 	const verdict = state.verdict?.toUpperCase();
 	const verdictSeverity =
-		verdict === "BLOCK"
+		verdict === "BLOCK" || verdict === "REJECT"
 			? "blocked"
 			: verdict === "ITERATE" || verdict === "WATCH"
 				? "warning"
-				: verdict === "APPROVE" || verdict === "CLEAR"
+				: verdict === "APPROVE" || verdict === "CLEAR" || verdict === "OKAY"
 					? "success"
 					: undefined;
+	const reviewPassChip = (
+		label: "arch" | "crit",
+		passes: number | undefined,
+		priority: number,
+	): WorkflowHudChip | null => {
+		if (
+			state.pendingApproval ||
+			typeof passes !== "number" ||
+			!Number.isFinite(passes) ||
+			passes <= 0 ||
+			typeof state.reviewPassBudget !== "number" ||
+			!Number.isFinite(state.reviewPassBudget) ||
+			state.reviewPassBudget <= 0
+		) {
+			return null;
+		}
+		return chip(label, `${passes}/${state.reviewPassBudget}`, priority);
+	};
+	const handoffValue = state.autoHandoff
+		? `${state.autoHandoff.configuredTarget}→${state.autoHandoff.effectiveTarget}${
+				state.autoHandoff.degradationReason ? `:${state.autoHandoff.degradationReason}` : ""
+			}`
+		: undefined;
+	const handoffSeverity = state.planningStuck
+		? "blocked"
+		: state.autoHandoff?.degradationReason
+			? "warning"
+			: undefined;
 	return {
 		version: 1,
 		summary: state.latestSummary,
@@ -217,7 +254,10 @@ export function buildRalplanHudSummary(state: RalplanHudState): WorkflowHudSumma
 				30,
 			),
 			chip("stages", state.stages, 35),
+			reviewPassChip("arch", state.architectPasses, 36),
+			reviewPassChip("crit", state.criticPasses, 38),
 			chip("verdict", verdict, 40, verdictSeverity),
+			chip("handoff", handoffValue, 45, handoffSeverity),
 		]),
 		...(state.updatedAt ? { updated_at: state.updatedAt } : {}),
 	};