@gajae-code/coding-agent 0.12.0 → 0.12.2

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/skill-state/active-state.ts

@@ -302,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;
@@ -615,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 {
@@ -747,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);

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

@@ -29,6 +29,12 @@ interface RalplanHudState extends WorkflowGateHudState {
 	verdict?: string;
 	latestSummary?: string;
 	pendingApproval?: boolean;
+	autoHandoff?: {
+		configuredTarget: string;
+		effectiveTarget: string;
+		degradationReason: string | null;
+	};
+	planningStuck?: boolean;
 	updatedAt?: string;
 }
 
@@ -222,6 +228,16 @@ export function buildRalplanHudSummary(state: RalplanHudState): WorkflowHudSumma
 		}
 		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,
@@ -241,6 +257,7 @@ export function buildRalplanHudSummary(state: RalplanHudState): WorkflowHudSumma
 			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 } : {}),
 	};