fix: add loadDefault() for platform-scope preference on ambiguity

loadDefault() picks the platform/app/database-scoped instance
when multiple module instances exist. This correctly resolves
the functions-test scenario where both 'platform' and 'org'
scoped invocation modules are provisioned — the worker should
use the platform instance when no entity_type is provided.

Author: pyramation

job/compute-worker/src/compute-log.ts

@@ -47,13 +47,11 @@ export class ComputeLogTracker {
         return;
       }
       if (err instanceof AmbiguousScopeError) {
-        const all = await this.loader.computeLog.loadAll(this.databaseId);
-        cfg = all[0];
+        cfg = await this.loader.computeLog.loadDefault(this.databaseId);
       } else {
         throw err;
       }
     }
-    if (!cfg) return;
 
     const qualifiedTable = `"${cfg.publicSchema}"."${cfg.computeLogTable}"`;
     try {
@@ -93,13 +91,11 @@ export class ComputeLogTracker {
         return 0;
       }
       if (err instanceof AmbiguousScopeError) {
-        const all = await this.loader.computeLog.loadAll(this.databaseId);
-        cfg = all[0];
+        cfg = await this.loader.computeLog.loadDefault(this.databaseId);
       } else {
         throw err;
       }
     }
-    if (!cfg) return 0;
 
     try {
       const result = await this.pool.query(

job/compute-worker/src/discovery.ts

@@ -39,8 +39,7 @@ export class FunctionDiscovery {
       return await this.loader.function.load(this.databaseId, null);
     } catch (err) {
       if (err instanceof AmbiguousScopeError) {
-        const all = await this.loader.function.loadAll(this.databaseId);
-        return all[0];
+        return await this.loader.function.loadDefault(this.databaseId);
       }
       throw err;
     }

job/compute-worker/src/invocation.ts

@@ -40,8 +40,7 @@ export class InvocationTracker {
     } catch (err) {
       if (err instanceof ModuleNotProvisionedError) return null;
       if (err instanceof AmbiguousScopeError) {
-        const all = await this.loader.invocation.loadAll(dbId);
-        return all[0] ?? null;
+        return await this.loader.invocation.loadDefault(dbId);
       }
       throw err;
     }

job/worker/src/compute-meter.ts

@@ -52,8 +52,7 @@ export function logComputeUsage(pool: Pool, entry: MeterEntry): string {
       return await loader.invocation.load(databaseId, entry.scope ?? null);
     } catch (err) {
       if (err instanceof AmbiguousScopeError) {
-        const all = await loader.invocation.loadAll(databaseId);
-        return all[0];
+        return await loader.invocation.loadDefault(databaseId);
       }
       throw err;
     }

job/worker/src/graph-complete.ts

@@ -27,8 +27,7 @@ async function resolveGraph(pool: Pool, databaseId: string, scope?: string | nul
     return await getLoader(pool).graph.load(databaseId, scope ?? null);
   } catch (err) {
     if (err instanceof AmbiguousScopeError) {
-      const all = await getLoader(pool).graph.loadAll(databaseId);
-      return all[0];
+      return await getLoader(pool).graph.loadDefault(databaseId);
     }
     throw err;
   }

job/worker/src/storage-meter.ts

@@ -36,8 +36,7 @@ async function resolveComputeLog(pool: Pool, databaseId: string, scope: string |
     return await getLoader(pool).computeLog.load(databaseId, scope);
   } catch (err) {
     if (err instanceof AmbiguousScopeError) {
-      const all = await getLoader(pool).computeLog.loadAll(databaseId);
-      return all[0];
+      return await getLoader(pool).computeLog.loadDefault(databaseId);
     }
     throw err;
   }

packages/agentic-server/src/inference-meter.ts

@@ -46,8 +46,7 @@ async function resolveComputeLog(pool: Pool, databaseId: string, scope: string |
     return await getLoader(pool).computeLog.load(databaseId, scope);
   } catch (err) {
     if (err instanceof AmbiguousScopeError) {
-      const all = await getLoader(pool).computeLog.loadAll(databaseId);
-      return all[0];
+      return await getLoader(pool).computeLog.loadDefault(databaseId);
     }
     throw err;
   }

packages/module-loader/src/generic-loader.ts

@@ -103,6 +103,31 @@ export class ModuleConfigLoader<T extends ScopedModuleConfig> {
     return all[0];
   }
 
+  /**
+   * Platform-level scope preferences (app/platform/database are equivalent).
+   * Used by loadDefault() to pick a non-entity instance when ambiguous.
+   */
+  private static readonly PLATFORM_SCOPES = ['platform', 'app', 'database'];
+
+  /**
+   * Load the default (platform-level) module instance.
+   *
+   * When only one instance exists, returns it. When multiple exist,
+   * prefers platform/app/database scope over entity scopes (org, etc.).
+   * Throws ModuleNotProvisionedError only if no instances exist at all.
+   */
+  async loadDefault(databaseId: string): Promise<T> {
+    const all = await this.loadAll(databaseId);
+    if (all.length === 0) {
+      throw new ModuleNotProvisionedError(this.moduleName, databaseId);
+    }
+    if (all.length === 1) return all[0];
+    const platformMatch = all.find((c) =>
+      ModuleConfigLoader.PLATFORM_SCOPES.includes(c.scope)
+    );
+    return platformMatch ?? all[0];
+  }
+
   /**
    * Invalidate cache for a specific database or all databases.
    */