fix: use >= for bundle cache mtime comparison to handle equal timestamps (#1155)

## Summary

- Changed bundle cache mtime comparison from strict `>` to `>=` in all 5
user extension loaders (models, reports, datastores, vaults, drivers)
- When source and bundle files share the same mtime (e.g. written in the
same second during a pre-commit hook), the cached bundle is now
correctly used instead of triggering a rebundle that may fail
- Added unit test verifying cached bundle is served when source and
bundle have equal mtimes

Closes systeminit/swamp-club#38

## Test Plan

- [x] New unit test: `bundleWithCache uses cache when source and bundle
have equal mtimes` — sets source and bundle to identical mtime via
`Deno.utime`, verifies cache is used without rebundling
- [x] All 51 existing `user_model_loader_test.ts` tests pass
- [x] Verified fix against manual reproduction in
`/tmp/swamp-repro-issue-38` — with equal mtimes the compiled binary now
logs `Using cached bundle` instead of rebundling
- [x] `deno check`, `deno lint`, `deno fmt` all pass

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-authored-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: stack72

src/domain/datastore/user_datastore_loader.ts

@@ -251,7 +251,7 @@ export class UserDatastoreLoader {
             },
             null,
           );
-          if (newestSourceMtime && bundleStat.mtime > newestSourceMtime) {
+          if (newestSourceMtime && bundleStat.mtime >= newestSourceMtime) {
             logger.debug`Using cached datastore bundle for ${relativePath}`;
             return await Deno.readTextFile(bundlePath);
           }

src/domain/drivers/user_driver_loader.ts

@@ -276,7 +276,7 @@ export class UserDriverLoader {
             },
             null,
           );
-          if (newestSourceMtime && bundleStat.mtime > newestSourceMtime) {
+          if (newestSourceMtime && bundleStat.mtime >= newestSourceMtime) {
             logger.debug`Using cached driver bundle for ${relativePath}`;
             return await Deno.readTextFile(bundlePath);
           }

src/domain/models/user_model_loader.ts

@@ -1156,7 +1156,7 @@ export class UserModelLoader {
             },
             null,
           );
-          if (newestSourceMtime && bundleStat.mtime > newestSourceMtime) {
+          if (newestSourceMtime && bundleStat.mtime >= newestSourceMtime) {
             logger.debug`Using cached bundle for ${relativePath}`;
             return await Deno.readTextFile(bundlePath);
           }

src/domain/models/user_model_loader_test.ts

@@ -2539,6 +2539,72 @@ export const model = {
   }
 });
 
+Deno.test("UserModelLoader bundleWithCache uses cache when source and bundle have equal mtimes", async () => {
+  const ts = Date.now();
+  const modelCode = `
+import { z } from "npm:zod@4";
+
+export const model = {
+  type: "@user/equal-mtime-${ts}",
+  version: "2026.02.09.1",
+  methods: {
+    run: {
+      description: "Run",
+      arguments: z.object({}),
+      execute: async () => ({ dataHandles: [] }),
+    },
+  },
+};
+`;
+
+  const repoDir = await Deno.makeTempDir({
+    prefix: "swamp_equal_mtime_repo_",
+  });
+  const modelsDir = await Deno.makeTempDir({
+    prefix: "swamp_equal_mtime_models_",
+  });
+
+  try {
+    // Write model and load to produce cached bundle
+    await Deno.writeTextFile(join(modelsDir, "model.ts"), modelCode);
+    const loader1 = new UserModelLoader(testDenoRuntime, repoDir);
+    await loader1.loadModels(modelsDir);
+
+    const ns = bundleNamespace(modelsDir, repoDir);
+    const bundlePath = join(repoDir, ".swamp", "bundles", ns, "model.js");
+    const cachedBundle = await Deno.readTextFile(bundlePath);
+
+    // Set source and bundle to the exact same mtime
+    const sharedMtime = new Date("2026-01-01T00:00:00Z");
+    await Deno.utime(join(modelsDir, "model.ts"), sharedMtime, sharedMtime);
+    await Deno.utime(bundlePath, sharedMtime, sharedMtime);
+
+    // Load again — should use cached bundle, not rebundle
+    const loader2 = new UserModelLoader(testDenoRuntime, repoDir);
+    await loader2.loadModels(modelsDir);
+
+    const bundleAfter = await Deno.readTextFile(bundlePath);
+
+    // Bundle content should be identical (cache was used, not rebundled)
+    assertEquals(
+      cachedBundle,
+      bundleAfter,
+      "Bundle content should be unchanged when source and bundle have equal mtimes",
+    );
+
+    // Bundle mtime should still be the shared time (not updated by a rebundle)
+    const bundleStatAfter = await Deno.stat(bundlePath);
+    assertEquals(
+      bundleStatAfter.mtime?.getTime(),
+      sharedMtime.getTime(),
+      "Bundle mtime should be unchanged — cache was used, no rebundle occurred",
+    );
+  } finally {
+    await Deno.remove(repoDir, { recursive: true });
+    await Deno.remove(modelsDir, { recursive: true });
+  }
+});
+
 Deno.test("UserModelLoader: accepts optional DatastorePathResolver", () => {
   // Verify the constructor accepts a resolver without errors
   const mockResolver = {

src/domain/reports/user_report_loader.ts

@@ -686,7 +686,7 @@ export class UserReportLoader {
             },
             null,
           );
-          if (newestSourceMtime && bundleStat.mtime > newestSourceMtime) {
+          if (newestSourceMtime && bundleStat.mtime >= newestSourceMtime) {
             logger.debug`Using cached report bundle for ${relativePath}`;
             return await Deno.readTextFile(bundlePath);
           }

src/domain/vaults/user_vault_loader.ts

@@ -277,7 +277,7 @@ export class UserVaultLoader {
             },
             null,
           );
-          if (newestSourceMtime && bundleStat.mtime > newestSourceMtime) {
+          if (newestSourceMtime && bundleStat.mtime >= newestSourceMtime) {
             logger.debug`Using cached vault bundle for ${relativePath}`;
             return await Deno.readTextFile(bundlePath);
           }