fix(discovery): compare contained-root identity at plain-stat precision

The user agent directory identity is captured with a plain fs.stat, whose
dev/ino are doubles. readContainedFile widened them to bigint and compared
against an exact bigint stat, so any NTFS file ID above 2^53 never matched
and native user-agent instructions were silently skipped on Windows. The
#4834 explicit-agent-dir case failed whenever the temp dir got such an ID.

Author: GJC Multisession

packages/coding-agent/changelog.d/win-file-id-precision.md

@@ -0,0 +1,3 @@
+### Fixed
+
+- Native user-agent instructions are no longer intermittently skipped on Windows when the agent directory's NTFS file ID exceeds 2^53: contained-file reads now compare the root identity in the same precision a plain `stat` captured it.

packages/coding-agent/src/discovery/helpers.ts

@@ -991,6 +991,21 @@ export async function scanSkillsFromDir(
 	return { items, warnings };
 }
 
+/**
+ * Compare a bigint-stat identity with one captured by a plain `fs.stat`.
+ *
+ * A plain stat reports `dev`/`ino` as doubles, so 64-bit values above 2^53
+ * (common NTFS file IDs) are already rounded. Widening that rounded double to
+ * a bigint can never equal the exact value; narrowing the exact value with the
+ * same IEEE rounding reproduces what the plain stat reported.
+ */
+export function bigintIdentityMatchesNumeric(
+	actual: { readonly dev: bigint; readonly ino: bigint },
+	expected: FileIdentity,
+): boolean {
+	return Number(actual.dev) === expected.dev && Number(actual.ino) === expected.ino;
+}
+
 /** Read a regular file that remains contained by its configured root. */
 export async function readContainedFile(
 	root: string,
@@ -1003,11 +1018,7 @@ export async function readContainedFile(
 		const capturedRoot = await captureDirectoryIdentity(root, true);
 		if (!capturedRoot) return null;
 		rootIdentity = capturedRoot;
-		if (
-			expectedRootIdentity !== undefined &&
-			(rootIdentity.dev !== BigInt(expectedRootIdentity.dev) ||
-				rootIdentity.ino !== BigInt(expectedRootIdentity.ino))
-		)
+		if (expectedRootIdentity !== undefined && !bigintIdentityMatchesNumeric(rootIdentity, expectedRootIdentity))
 			return null;
 		await SkillDiscoveryTestHooks.afterContainedRootValidated?.(root);
 		if (!(await directoryIdentityIsCurrent(root, rootIdentity, true))) return null;

packages/coding-agent/test/discovery-identity-precision.test.ts

@@ -0,0 +1,24 @@
+import { describe, expect, it } from "bun:test";
+import { bigintIdentityMatchesNumeric } from "../src/discovery/helpers";
+
+describe("bigintIdentityMatchesNumeric", () => {
+	it("matches a 64-bit file ID that a plain stat rounded to a double", () => {
+		// NTFS file IDs routinely exceed 2^53; a plain fs.stat reports the rounded double.
+		const exact = { dev: 3_430_812_034n, ino: 2n ** 60n + 12_345n };
+		const plainStat = { dev: Number(exact.dev), ino: Number(exact.ino) };
+
+		expect(BigInt(plainStat.ino)).not.toBe(exact.ino);
+		expect(bigintIdentityMatchesNumeric(exact, plainStat)).toBe(true);
+	});
+
+	it("rejects a different directory", () => {
+		const exact = { dev: 7n, ino: 42n };
+		expect(bigintIdentityMatchesNumeric(exact, { dev: 7, ino: 43 })).toBe(false);
+		expect(bigintIdentityMatchesNumeric(exact, { dev: 8, ino: 42 })).toBe(false);
+	});
+
+	it("rejects a large file ID beyond double rounding distance", () => {
+		const exact = { dev: 1n, ino: 2n ** 60n };
+		expect(bigintIdentityMatchesNumeric(exact, { dev: 1, ino: Number(2n ** 60n + 4096n) })).toBe(false);
+	});
+});