@gajae-code/coding-agent 0.18.12 → 0.19.0

package/src/commit/map-reduce/index.ts

@@ -23,9 +23,9 @@ export interface MapReduceInput {
 	model: Model<Api>;
 	apiKey: string;
 	thinkingLevel?: ThinkingLevel;
-	smolModel: Model<Api>;
-	smolApiKey: string;
-	smolThinkingLevel?: ThinkingLevel;
+	secondaryModel: Model<Api>;
+	secondaryApiKey: string;
+	secondaryThinkingLevel?: ThinkingLevel;
 	diff: string;
 	stat: string;
 	scopeCandidates: string;
@@ -45,15 +45,15 @@ export function shouldUseMapReduce(diff: string, settings?: MapReduceSettings):
 }
 
 /**
- * Run map-reduce analysis for large diffs using smol + primary models.
+ * Run map-reduce analysis for large diffs using the secondary (map) and primary (reduce) models.
  */
 
 export async function runMapReduceAnalysis(input: MapReduceInput): Promise<ConventionalAnalysis> {
 	const fileDiffs = parseFileDiffs(input.diff).filter(file => !isExcludedFile(file.filename));
 	const observations = await runMapPhase({
-		model: input.smolModel,
-		apiKey: input.smolApiKey,
-		thinkingLevel: input.smolThinkingLevel,
+		model: input.secondaryModel,
+		apiKey: input.secondaryApiKey,
+		thinkingLevel: input.secondaryThinkingLevel,
 		files: fileDiffs,
 		config: input.settings,
 	});

package/src/commit/pipeline.ts

@@ -53,9 +53,9 @@ async function runLegacyCommitCommand(args: CommitCommandArgs): Promise<void> {
 		thinkingLevel: primaryThinkingLevel,
 	} = await resolvePrimaryModel(args.model, settings, modelRegistry);
 	const {
-		model: smolModel,
-		apiKey: smolApiKey,
-		thinkingLevel: smolThinkingLevel,
+		model: secondaryModel,
+		apiKey: secondaryApiKey,
+		thinkingLevel: secondaryThinkingLevel,
 	} = await resolveSecondaryCommitModel(settings, modelRegistry, primaryModel, primaryApiKey);
 
 	let stagedFiles = await git.diff.changedFiles(cwd, { cached: true });
@@ -102,9 +102,9 @@ async function runLegacyCommitCommand(args: CommitCommandArgs): Promise<void> {
 		primaryModel,
 		primaryApiKey,
 		primaryThinkingLevel,
-		smolModel,
-		smolApiKey,
-		smolThinkingLevel,
+		secondaryModel,
+		secondaryApiKey,
+		secondaryThinkingLevel,
 		commitSettings,
 	});
 
@@ -148,9 +148,9 @@ async function generateAnalysis(input: {
 	primaryModel: Model<Api>;
 	primaryApiKey: string;
 	primaryThinkingLevel?: ThinkingLevel;
-	smolModel: Model<Api>;
-	smolApiKey: string;
-	smolThinkingLevel?: ThinkingLevel;
+	secondaryModel: Model<Api>;
+	secondaryApiKey: string;
+	secondaryThinkingLevel?: ThinkingLevel;
 	commitSettings: {
 		mapReduceEnabled: boolean;
 		mapReduceMinFiles: number;
@@ -172,9 +172,9 @@ async function generateAnalysis(input: {
 			model: input.primaryModel,
 			apiKey: input.primaryApiKey,
 			thinkingLevel: input.primaryThinkingLevel,
-			smolModel: input.smolModel,
-			smolApiKey: input.smolApiKey,
-			smolThinkingLevel: input.smolThinkingLevel,
+			secondaryModel: input.secondaryModel,
+			secondaryApiKey: input.secondaryApiKey,
+			secondaryThinkingLevel: input.secondaryThinkingLevel,
 			diff: input.diff,
 			stat: input.stat,
 			scopeCandidates: input.scopeCandidates,

package/src/config/autorouting-tier-map.ts

@@ -44,7 +44,8 @@ type NormalizedAutoroutingCuratedTierMap = {
 export const TIER_MAP_VERSION = 1;
 
 export const CURATED_TIER_LABELS = {
-	"anthropic/claude-haiku-4-5": [{ tier: "fast", rank: 1 }],
+	"anthropic/claude-haiku-5-5": [{ tier: "fast", rank: 1 }],
+	"anthropic/claude-haiku-4-5": [{ tier: "fast", rank: 2 }],
 	"anthropic/claude-sonnet-5-5": [{ tier: "balanced", rank: 1 }],
 	"anthropic/claude-sonnet-5": [{ tier: "balanced", rank: 2 }],
 	"anthropic/claude-sonnet-4-6": [{ tier: "balanced", rank: 3 }],
@@ -77,6 +78,24 @@ export const CURATED_TIER_LABELS = {
 
 /** Generated from packages/ai/src/models.json at feature land: 3936 in-scope baseline skips. */
 export const TIER_MAP_SKIP_LIST = {
+	"amazon-bedrock/anthropic.claude-haiku-5-5": {
+		rationale: "Haiku 5.5 Bedrock catalog addition; not yet curated",
+	},
+	"amazon-bedrock/au.anthropic.claude-haiku-5-5": {
+		rationale: "Haiku 5.5 Bedrock catalog addition; not yet curated",
+	},
+	"amazon-bedrock/eu.anthropic.claude-haiku-5-5": {
+		rationale: "Haiku 5.5 Bedrock catalog addition; not yet curated",
+	},
+	"amazon-bedrock/global.anthropic.claude-haiku-5-5": {
+		rationale: "Haiku 5.5 Bedrock catalog addition; not yet curated",
+	},
+	"amazon-bedrock/jp.anthropic.claude-haiku-5-5": {
+		rationale: "Haiku 5.5 Bedrock catalog addition; not yet curated",
+	},
+	"amazon-bedrock/us.anthropic.claude-haiku-5-5": {
+		rationale: "Haiku 5.5 Bedrock catalog addition; not yet curated",
+	},
 	"amazon-bedrock/au.anthropic.claude-sonnet-5-5": {
 		rationale: "Sonnet 5.5 catalog addition (#6111); not yet curated",
 	},

package/src/config/config-file.ts

@@ -1,18 +1,121 @@
+import { randomBytes } from "node:crypto";
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { getAgentDir, isEnoent, logger } from "@gajae-code/utils";
+import { renameNoReplacePath } from "@gajae-code/natives";
+import { getAgentDir, isEnoent, isFsError, logger } from "@gajae-code/utils";
 import { JSONC, YAML } from "bun";
 import type { ZodType } from "zod/v4";
 
+// Volumes without hard links fail `link`. Windows maps FAT ERROR_INVALID_FUNCTION to EISDIR.
+const HARD_LINK_UNAVAILABLE = new Set(["EACCES", "EISDIR", "ENOSYS", "ENOTSUP", "EOPNOTSUPP", "EPERM", "EXDEV"]);
+
 /** Minimal subset of the AJV ConfigSchemaError shape this module actually relies on. */
 interface ConfigSchemaError {
 	instancePath: string;
 	message: string | undefined;
 }
 
+/** True when the final path component exists, including a dangling symlink. */
+function ymlPathPresent(ymlPath: string): boolean {
+	try {
+		fs.lstatSync(ymlPath);
+		return true;
+	} catch (error) {
+		if (isEnoent(error)) return false;
+		throw error;
+	}
+}
+
+function hardLinkUnavailable(error: unknown): boolean {
+	return isFsError(error) && HARD_LINK_UNAVAILABLE.has(error.code);
+}
+
+function stagedRegularFile(tmpPath: string): boolean {
+	try {
+		return fs.lstatSync(tmpPath).isFile();
+	} catch {
+		return false;
+	}
+}
+
+function discardStaged(tmpPath: string): void {
+	try {
+		fs.unlinkSync(tmpPath);
+	} catch {
+		// Unpublished, or the no-replace rename already moved this name.
+	}
+}
+
+/** Publish the completed private file when `link` is not supported. Never replaces `ymlPath`. */
+function publishStagedWithoutHardLink(tmpPath: string, ymlPath: string): void {
+	const published = renameNoReplacePath(tmpPath, ymlPath);
+	if (!published.ok && published.reason !== "destination_exists") {
+		discardStaged(tmpPath);
+		throw new Error(`config migration could not publish without a hard link (${published.reason})`);
+	}
+	discardStaged(tmpPath);
+}
+
+/**
+ * Publish a new regular file as mode 0600. The bytes go to a private inode
+ * opened with O_EXCL and O_NOFOLLOW. `link` then attaches that inode to
+ * `ymlPath` and fails when the name exists, so a final-component symlink is
+ * not followed and an existing file is not replaced. A volume without hard
+ * links publishes that same completed file with a no-replace rename. The
+ * destination name stays absent until the bytes are complete.
+ */
+function writeNewOwnerOnlyNoFollow(ymlPath: string, content: string): void {
+	// Ancestor symlinks only. The final component stays unresolved so no-follow still applies.
+	ymlPath = path.join(fs.realpathSync(path.dirname(ymlPath)), path.basename(ymlPath));
+	const noFollow = process.platform === "win32" ? 0 : (fs.constants.O_NOFOLLOW ?? 0);
+	const tmpPath = path.join(
+		path.dirname(ymlPath),
+		`.${path.basename(ymlPath)}.${process.pid}.${randomBytes(8).toString("hex")}.tmp`,
+	);
+	let fd: number | undefined;
+	try {
+		fd = fs.openSync(tmpPath, fs.constants.O_WRONLY | fs.constants.O_CREAT | fs.constants.O_EXCL | noFollow, 0o600);
+		if (process.platform !== "win32") fs.fchmodSync(fd, 0o600);
+		fs.writeFileSync(fd, content);
+		fs.fsyncSync(fd);
+		fs.closeSync(fd);
+		fd = undefined;
+	} catch (error) {
+		if (fd !== undefined) {
+			try {
+				fs.closeSync(fd);
+			} catch {
+				// The original failure is the one that must surface.
+			}
+			try {
+				fs.unlinkSync(tmpPath);
+			} catch {
+				// The destination name was not published.
+			}
+		}
+		throw error;
+	}
+	try {
+		fs.linkSync(tmpPath, ymlPath);
+	} catch (error) {
+		// The name is already present: a finished peer publish, or a file or symlink we must not replace.
+		if (isFsError(error) && (error.code === "EEXIST" || error.code === "ELOOP")) {
+			discardStaged(tmpPath);
+			return;
+		}
+		if (hardLinkUnavailable(error) && stagedRegularFile(tmpPath)) {
+			publishStagedWithoutHardLink(tmpPath, ymlPath);
+			return;
+		}
+		discardStaged(tmpPath);
+		throw error;
+	}
+	discardStaged(tmpPath);
+}
+
 function migrateJsonToYml(jsonPath: string, ymlPath: string) {
 	try {
-		if (fs.existsSync(ymlPath)) return;
+		if (ymlPathPresent(ymlPath)) return;
 		if (!fs.existsSync(jsonPath)) return;
 
 		const content = fs.readFileSync(jsonPath, "utf-8");
@@ -21,7 +124,7 @@ function migrateJsonToYml(jsonPath: string, ymlPath: string) {
 			logger.warn("migrateJsonToYml: invalid json structure", { path: jsonPath });
 			return;
 		}
-		fs.writeFileSync(ymlPath, YAML.stringify(parsed, null, 2));
+		writeNewOwnerOnlyNoFollow(ymlPath, YAML.stringify(parsed, null, 2));
 	} catch (error) {
 		logger.warn("migrateJsonToYml: migration failed", { error: String(error) });
 	}

package/src/config/config-hot-reload.ts

@@ -242,6 +242,14 @@ export class ConfigHotReloadWatcher {
 		await this.#initializeBinding(binding);
 	}
 
+	/**
+	 * Test-only: request the same scan an fs event would schedule. Tests that
+	 * exercise the watcher cannot rely on platform fs-event delivery timing.
+	 */
+	__testRequestScan(): void {
+		if (this.#binding && this.#isCurrent(this.#binding)) this.#scheduleScan(this.#binding);
+	}
+
 	/** Closes all watches and cancels or fences pending and in-flight callbacks. */
 	dispose(): void {
 		if (this.#disposed) return;