@gajae-code/coding-agent 0.18.8 → 0.18.9

package/src/config/file-lock.ts

@@ -1368,7 +1368,6 @@ function ownerGenerationIsDead(owner: FileLockOwnerToken): boolean {
 
 /** Outcome of a guarded lock-dir removal attempt (`removeFileLockDirForGc`). */
 export type FileLockGcRemoval = "removed" | "owner_changed" | "missing" | "cleanup_failed";
-
 type LockStaleSnapshot =
 	| { stale: false }
 	| { stale: true; owner: FileLockOwnerToken; identity: GenericFileLockDirIdentity };
@@ -1809,12 +1808,9 @@ async function staleLockSnapshot(
 		throw error;
 	}
 	if (!info) {
-		// A directory without a valid owner record is either a contender between
-		// native directory ownership and metadata publication, or malformed state
-		// with no PID/incarnation/host proof of any process generation. Neither
-		// case carries liveness evidence, so elapsed time and byte stability must
-		// never make this namespace reclaimable: only an independently committed
-		// owner record proving its process generation dead authorizes removal.
+		// An ownerless directory has no generation or liveness proof. Age and
+		// emptiness cannot distinguish interrupted cleanup from a live legacy holder
+		// or a paused acquisition, so every platform fails closed.
 		return { stale: false };
 	}
 
@@ -1857,8 +1853,6 @@ async function staleLockSnapshot(
 	return { stale: false };
 }
 
-type StaleLockRemovalAttempt = { removed: true } | { removed: false; failure?: FileLockStaleRemovalFailure };
-
 type RecordedStaleRemovalFailure = {
 	owner: FileLockOwnerToken;
 	identity: GenericFileLockDirIdentity;
@@ -1902,10 +1896,12 @@ function manualLockCleanupCommand(lockPath: string): string {
 	return `rm -rf -- '${quotedPath}'`;
 }
 
+type FileLockRemovalAttempt = { removed: true } | { removed: false; failure?: FileLockStaleRemovalFailure };
+
 async function removeStaleLockForAcquire(
 	lockPath: string,
 	snapshot: LockStaleSnapshot,
-): Promise<StaleLockRemovalAttempt> {
+): Promise<FileLockRemovalAttempt> {
 	if (!snapshot.stale) return { removed: false };
 	try {
 		const outcome = await removeFileLockDirForGc(lockPath, snapshot.owner, snapshot.identity);
@@ -2132,7 +2128,9 @@ async function tryAcquireLock(
 			}
 		}
 		if (!publishedSuccessfully) {
-			if (published.reason === "destination_exists") return null;
+			if (published.reason === "destination_exists") {
+				return null;
+			}
 			const failure = new Error(
 				`Failed to publish file lock: ${published.code ?? published.reason ?? "unknown"}.`,
 			) as NodeJS.ErrnoException;

package/src/config/model-profile-activation.ts

@@ -1820,6 +1820,10 @@ export async function applyPreparedModelProfileActivation(
 	} catch (error) {
 		const activationWasCancelled = error instanceof ModelProfileActivationSupersededError;
 		const selectionSuperseded = options.isCurrent?.() === false;
+		const shouldRestoreFallbackRuntimeState =
+			prepared.previousDefaultFallbackRuntimeState !== undefined &&
+			(!selectionSuperseded ||
+				sameSerializedValue(prepared.session.getDefaultFallbackRuntimeState?.(), activatedFallbackRuntimeState));
 		const rollbackErrors: Array<{ stage: string; error: unknown }> = [];
 		const restore = (stage: string, action: () => void): void => {
 			try {
@@ -1945,11 +1949,7 @@ export async function applyPreparedModelProfileActivation(
 				),
 			);
 		}
-		if (
-			prepared.previousDefaultFallbackRuntimeState &&
-			(!selectionSuperseded ||
-				sameSerializedValue(prepared.session.getDefaultFallbackRuntimeState?.(), activatedFallbackRuntimeState))
-		) {
+		if (shouldRestoreFallbackRuntimeState) {
 			restore("restore fallback runtime", () =>
 				prepared.session.restoreDefaultFallbackRuntimeState?.(prepared.previousDefaultFallbackRuntimeState!),
 			);

package/src/coordinator-mcp/server.ts

@@ -210,6 +210,8 @@ type CoordinatorBrokerStage = "ensure" | "read" | "connect" | "request" | "close
 function toCoordinatorBrokerError(stage: CoordinatorBrokerStage, error: unknown): SdkClientError {
 	if (stage === "request" && error instanceof SdkClientError) return error;
 	if (stage === "ensure") {
+		// Attach-only mode refuses with the public unavailability code; keep it.
+		if (error instanceof SdkClientError && error.code === "broker_unavailable") return error;
 		if (error instanceof AggregateError)
 			return new SdkClientError(
 				"broker_cleanup_unverified",

package/src/customization/inventory.ts

@@ -74,18 +74,6 @@ function redactServerForDisplay(server: Record<string, unknown>): Record<string,
 // Skills
 // ---------------------------------------------------------------------------
 
-async function readImportMarker(skillPath: string): Promise<string | null> {
-	try {
-		const content = await fs.readFile(skillPath, "utf-8");
-		const { frontmatter } = parseFrontmatter(content, { level: "off" });
-		// parseFrontmatter camelCases keys: x-gjc-imported-from → xGjcImportedFrom.
-		const marker = frontmatter[IMPORTED_FROM_FRONTMATTER_KEY] ?? frontmatter.xGjcImportedFrom;
-		return typeof marker === "string" ? marker : null;
-	} catch {
-		return null;
-	}
-}
-
 function importedProductLabel(marker: string): string {
 	return marker === "claude-code" ? "Claude Code" : marker === "codex" ? "Codex" : marker;
 }
@@ -102,7 +90,7 @@ async function loadSkillRows(options: LoadCustomizationInventoryOptions, _warnin
 	for (const record of records) {
 		managedPaths.add(path.resolve(record.path));
 		const scope: GjcScope = record.scope === "project" ? "project" : "global";
-		const marker = await readImportMarker(record.path);
+		const marker = record.importedFrom ?? null;
 		let status: InventoryStatus;
 		const diagnostics: string[] = [];
 		if (options.policy?.enabled === false) {

package/src/dap/config.ts

@@ -1,6 +1,6 @@
 import * as path from "node:path";
 import { isRecord } from "@gajae-code/utils";
-import { hasRootMarkers, resolveCommand } from "../lsp/config";
+import { hasRootMarkers, resolveTrustedCommand } from "../lsp/config";
 import DEFAULTS from "./defaults.json" with { type: "json" };
 import type { DapAdapterConfig, DapResolvedAdapter } from "./types";
 
@@ -51,7 +51,7 @@ export function getAdapterConfigs(): Record<string, DapAdapterConfig> {
 export function resolveAdapter(adapterName: string, cwd: string): DapResolvedAdapter | null {
 	const config = DEFAULT_ADAPTERS[adapterName];
 	if (!config) return null;
-	const resolvedCommand = resolveCommand(config.command, cwd);
+	const resolvedCommand = resolveTrustedCommand(config.command, cwd);
 	if (!resolvedCommand) return null;
 	return {
 		name: adapterName,

package/src/defaults/gjc/extensions/grok-cli-vendor/src/provider/register.ts

@@ -7,6 +7,7 @@ import { Effort } from '@gajae-code/ai/model-thinking';
 import type { OAuthCredentials, OAuthLoginCallbacks } from '@gajae-code/ai/utils/oauth/types';
 import { loginXai, refreshXaiToken, XAI_OAUTH_SCOPE } from '@gajae-code/ai/utils/oauth/xai';
 import type { ExtensionAPI, ProviderConfig } from '@gajae-code/coding-agent';
+import { tagProviderRequestHandler } from '../../../../../../extensibility/extensions/function-hooks-internal';
 import {
   type GrokCliModelConfig,
   getMaxReasoningEffort,
@@ -102,13 +103,16 @@ export default function registerGrokCli(api: ExtensionAPI) {
     }
   });
 
-  api.on('before_provider_request', (event, ctx) => {
-    if (ctx.model?.provider !== 'grok-build') return;
+  api.on(
+    'before_provider_request',
+    tagProviderRequestHandler('grok-build', (event, ctx) => {
+      if (ctx.model?.provider !== 'grok-build') return;
 
-    const modelId = ctx.model?.id ?? '';
-    const sessionId = ctx.sessionManager?.getSessionId();
-    return sanitizePayload(event.payload as Record<string, unknown>, modelId, sessionId, ctx.cwd);
-  });
+      const modelId = ctx.model?.id ?? '';
+      const sessionId = ctx.sessionManager?.getSessionId();
+      return sanitizePayload(event.payload as Record<string, unknown>, modelId, sessionId, ctx.cwd);
+    }),
+  );
 
   registerUsageCommand(api);
 }

package/src/discovery/builtin.ts

@@ -138,7 +138,9 @@ async function loadMCPServers(ctx: LoadContext): Promise<LoadResult<MCPServer>>
 		const data = tryParseJson<{ mcpServers?: Record<string, unknown> }>(content);
 		if (!data?.mcpServers) return result;
 
-		const expanded = expandEnvVarsDeep(data.mcpServers);
+		// Project mcp.json is repo content. Skip secret-named ${VAR} the same way
+		// project ssh.json does; user scope still expands those names.
+		const expanded = expandEnvVarsDeep(data.mcpServers, undefined, level === "project");
 		for (const [serverName, config] of Object.entries(expanded)) {
 			const serverConfig = config as Record<string, unknown>;
 

package/src/discovery/helpers.ts

@@ -878,7 +878,7 @@ export async function scanSkillsFromDir(
 			await handle.close();
 		}
 	};
-	const loadSkill = async (candidatePath: string) => {
+	const loadSkill = async (candidatePath: string, expectedCanonicalPath?: string) => {
 		try {
 			const linkIdentities = (
 				await Promise.all([
@@ -889,6 +889,13 @@ export async function scanSkillsFromDir(
 			await SkillDiscoveryTestHooks.afterSkillLinksCaptured?.(candidatePath);
 			const skillPath = await fs.promises.realpath(candidatePath);
 			await SkillDiscoveryTestHooks.afterSkillPathResolved?.(candidatePath);
+			if (
+				expectedCanonicalPath &&
+				normalizePathForComparison(skillPath) !== normalizePathForComparison(expectedCanonicalPath)
+			) {
+				warnings.push(`Refusing changed skill path during isolated-home scan: ${candidatePath}`);
+				return;
+			}
 			const allowOutsideRoot = options.allowExternalUserSkillSymlinks && level === "user";
 			if (!isWithinRoot(skillPath) && !allowOutsideRoot) {
 				const remedy =
@@ -971,14 +978,10 @@ export async function scanSkillsFromDir(
 	for (const entry of entries) {
 		if (entry.name.startsWith(".")) continue;
 		if (!entry.isDirectory() && !entry.isSymbolicLink()) continue;
-		const skillPath = await canonicalizePathWithinHome(
-			_ctx,
-			path.join(scanDir, entry.name, "SKILL.md"),
-			containmentRoot,
-			scope,
-		);
-		if (!skillPath) continue;
-		work.push(loadSkill(skillPath));
+		const candidatePath = path.join(scanDir, entry.name, "SKILL.md");
+		const canonicalSkillPath = await canonicalizePathWithinHome(_ctx, candidatePath, containmentRoot, scope);
+		if (!canonicalSkillPath) continue;
+		work.push(loadSkill(candidatePath, _ctx.isolatedHome ? canonicalSkillPath : undefined));
 	}
 	await Promise.all(work);
 

package/src/discovery/mcp-json.ts

@@ -154,7 +154,12 @@ function validateExactMCPConfig(config: unknown): {
 /**
  * Transform raw MCP config to canonical MCPServer format.
  */
-function transformMCPConfig(config: MCPConfigFile, source: SourceMeta, quiet = false): MCPServer[] {
+function transformMCPConfig(
+	config: MCPConfigFile,
+	source: SourceMeta,
+	quiet = false,
+	skipSensitiveEnvNames = false,
+): MCPServer[] {
 	const servers: MCPServer[] = [];
 
 	if (config.mcpServers) {
@@ -229,15 +234,17 @@ function transformMCPConfig(config: MCPConfigFile, source: SourceMeta, quiet = f
 				_source: source,
 			};
 
-			// Expand environment variables
-			if (server.command) server.command = expandEnvVarsDeep(server.command);
-			if (server.args) server.args = expandEnvVarsDeep(server.args);
-			if (server.env) server.env = expandEnvVarsDeep(server.env);
-			if (server.cwd) server.cwd = expandEnvVarsDeep(server.cwd);
-			if (server.url) server.url = expandEnvVarsDeep(server.url);
-			if (server.headers) server.headers = expandEnvVarsDeep(server.headers);
-			if (server.auth) server.auth = expandEnvVarsDeep(server.auth);
-			if (server.oauth) server.oauth = expandEnvVarsDeep(server.oauth);
+			// Repo-root mcp.json is project content. Exact `--mcp-config` passes
+			// skipSensitiveEnvNames false so a trusted file can still reference secrets.
+			const expand = <T>(value: T): T => expandEnvVarsDeep(value, undefined, skipSensitiveEnvNames);
+			if (server.command) server.command = expand(server.command);
+			if (server.args) server.args = expand(server.args);
+			if (server.env) server.env = expand(server.env);
+			if (server.cwd) server.cwd = expand(server.cwd);
+			if (server.url) server.url = expand(server.url);
+			if (server.headers) server.headers = expand(server.headers);
+			if (server.auth) server.auth = expand(server.auth);
+			if (server.oauth) server.oauth = expand(server.oauth);
 			servers.push(server);
 		}
 	}
@@ -446,7 +453,7 @@ async function readExactMCPConfigFile(filePath: string): Promise<string | null>
 export async function loadMCPJsonFile(
 	filePath: string,
 	level: "user" | "project",
-	options?: { quiet?: boolean; useCache?: boolean; readOptions?: ReadFileOptions },
+	options?: { quiet?: boolean; useCache?: boolean; readOptions?: ReadFileOptions; skipSensitiveEnvNames?: boolean },
 ): Promise<MCPJsonLoadResult> {
 	const warnings: string[] = [];
 	const items: MCPServer[] = [];
@@ -503,7 +510,7 @@ export async function loadMCPJsonFile(
 		validConfig = config as MCPConfigFile;
 	}
 	const source = createSourceMeta(PROVIDER_ID, sourcePath, level);
-	items.push(...transformMCPConfig(validConfig, source, options?.quiet));
+	items.push(...transformMCPConfig(validConfig, source, options?.quiet, options?.skipSensitiveEnvNames === true));
 
 	return {
 		items,
@@ -521,6 +528,7 @@ async function load(ctx: LoadContext): Promise<LoadResult<MCPServer>> {
 		filenames.map(filename =>
 			loadMCPJsonFile(path.join(ctx.cwd, filename), "project", {
 				readOptions: getReadOptions(ctx, "project"),
+				skipSensitiveEnvNames: true,
 			}),
 		),
 	);