agency-lang 0.7.2 → 0.7.4

package/dist/lib/cli/commands.js

@@ -1,25 +1,14 @@
 import { generateAgency } from "../backends/agencyGenerator.js";
 import { loadConfigSafe } from "../config.js";
-import { generateTypeScript } from "../index.js";
-import { initPlanForModule } from "../backends/typescriptGenerator.js";
-import { resolveImports } from "../preprocessors/importResolver.js";
-import { resolveReExports } from "../preprocessors/resolveReExports.js";
-import { liftCallbackBlocks } from "../preprocessors/liftCallbacks.js";
-import { buildCompilationUnit } from "../compilationUnit.js";
-import { SymbolTable } from "../symbolTable.js";
-import { formatErrors, typeCheck } from "../typeChecker/index.js";
-import { buildCompiledClosure, CompileClosureError, } from "../compiler/compileClosure.js";
 import { spawn } from "child_process";
-import { transformSync } from "esbuild";
 import * as fs from "fs";
 import { createRequire } from "module";
 import * as path from "path";
-import { getStdlibDir, isNonTemplatedStdlib, isPkgImport, isStdlibImport, resolveAgencyImportPath, } from "../importPaths.js";
-import { CompileStrategy, RunStrategy, } from "../importStrategy.js";
+import { RunStrategy } from "../importStrategy.js";
 import { parseAgency, replaceBlankLines } from "../parser.js";
-import { parseAgencyFileCached } from "../parseCache.js";
 import { fileURLToPath, pathToFileURL } from "url";
-import { findRecursively, getImports } from "./util.js";
+import { findRecursively } from "./util.js";
+import { createBuildSession, readFile, } from "../compiler/buildSession.js";
 // Returns the file:// URL of the ESM loader-register shim shipped with the
 // agency-lang package. Passing this to `node --import=<url>` causes Node to
 // fall back to agency-lang's own node_modules when resolving bare specifiers,
@@ -122,271 +111,47 @@ export function parse(contents, config, applyTemplate = true, lower = true) {
     }
     return parseResult.result;
 }
-export function readFile(inputFile) {
-    if (!fs.existsSync(inputFile)) {
-        console.error(`Error: Input file '${inputFile}' not found`);
-        process.exit(1);
-    }
-    return fs.readFileSync(inputFile, "utf-8");
+export { readFile };
+// The default session backing the legacy module-level entry points
+// (compile/compileMany/resetCompilationCache). Deliberately the ONLY
+// compile-pipeline state left in this file: CLI processes are
+// single-session by nature, and watch mode resets it between rebuilds.
+// All pipeline logic lives in lib/compiler/buildSession.ts.
+//
+// Created LAZILY, not at module top level: `agency pack` bundles compiled
+// programs whose import chain reaches this module for small helpers
+// (readFile, loadConfig). An eager createBuildSession() call is a
+// top-level side effect that defeats esbuild tree-shaking and drags the
+// entire codegen subtree into every packed artifact (~16k extra lines,
+// caught by pack.test.ts).
+let defaultSession = null;
+function getDefaultSession() {
+    return (defaultSession ??= createBuildSession());
 }
-const compiledFiles = new Set();
-// Cached `CompiledClosure` for the current compile session. Built once
-// at the outermost `compile()` call (when no per-file recursion is in
-// progress) and reused by every per-file emit. Cleared by
-// `resetCompilationCache()`.
-let currentClosure = null;
 export function resetCompilationCache() {
-    compiledFiles.clear();
-    currentClosure = null;
+    defaultSession = null;
 }
 /**
  * Compile a set of entry files under ONE union closure, like the
  * directory branch of `compile()` does. Callers with many entry points
  * (the test runner's precompile pass) use this instead of per-file
- * `compile()` calls, which would rebuild the closure once per entry via
- * `ensureCompiledClosure`'s covers-check.
+ * `compile()` calls, which would rebuild the closure once per entry.
  *
  * Unlike the CLI directory branch, closure errors THROW
  * (`CompileClosureError`) instead of exiting, so programmatic callers
  * can attach context. Parse/typecheck failures inside per-file
  * `compile()` keep their existing exit behavior.
- *
- * `options.closure` lets a caller that already built the union closure
- * (e.g. to run analyses over `closure.programs`) hand it in rather than
- * paying for a rebuild. It MUST cover every file in `files`, otherwise
- * `ensureCompiledClosure` clears the session cache mid-loop and the
- * one-compile-per-module guarantee is lost.
  */
 export function compileMany(config, files, options) {
-    const absFiles = files.map((f) => path.resolve(f));
-    if (absFiles.length === 0)
-        return;
-    currentClosure = options?.closure ?? buildCompiledClosure(absFiles, config);
-    compiledFiles.clear();
-    for (const file of absFiles) {
-        compile(config, file, undefined, {
-            quiet: options?.quiet,
-            allowTestImports: options?.allowTestImports,
-        });
-    }
+    getDefaultSession().compileMany(config, files, options);
 }
 /**
- * Build the import-closure analysis once per compile session — at the
- * outermost call, before any recursive per-file compile() runs. The
- * recursive children reuse the cached closure to get per-module init
- * plans without re-parsing.
- *
- * "Outermost call" = no `options.symbolTable` (passed by recursive
- * children). When the outermost call's entry file changes (e.g. the
- * `agency test` runner iterates several .test.json fixtures in one
- * process), the cached closure no longer covers the new entry's
- * imports so we rebuild and drop the stale `compiledFiles` set.
- * Without that drop, downstream codegen would look up plans for
- * modules that aren't in the closure and emit an empty init plan.
- *
- * Stdlib files compile under their own entry (e.g., when a user runs
- * `agency compile std/...`) but most user code reaches them via
- * `import "std::..."`, which the closure walker intentionally skips.
- * Avoid building a closure rooted at a stdlib file — its imports are
- * structured differently and we don't need the analysis there.
+ * Compile an .agency file (or directory of them) to JavaScript. Thin
+ * delegate over the default BuildSession — all pipeline logic and caching
+ * state live in lib/compiler/buildSession.ts.
  */
-function ensureCompiledClosure(absoluteInputFile, config, hasSymbolTable, verbose) {
-    const isOutermostCall = !hasSymbolTable;
-    const isStdlibEntry = absoluteInputFile.startsWith(getStdlibDir() + path.sep);
-    const closureCoversEntry = currentClosure?.programs[absoluteInputFile] !== undefined;
-    if (!isOutermostCall || isStdlibEntry || closureCoversEntry)
-        return;
-    currentClosure = null;
-    compiledFiles.clear();
-    try {
-        const ccStartTime = performance.now();
-        currentClosure = buildCompiledClosure(absoluteInputFile, config);
-        const ccEndTime = performance.now();
-        logTime({ label: "Built compile closure", start: ccStartTime, end: ccEndTime, verbose });
-    }
-    catch (e) {
-        if (e instanceof CompileClosureError) {
-            console.error(e.message);
-            process.exit(1);
-        }
-        throw e;
-    }
-}
-function runTypecheck(liftedProgram, config, info, absoluteInputFile, verbose) {
-    const tc = config.typechecker;
-    if (!tc?.enabled && !tc?.strict)
-        return;
-    const tcStartTime = performance.now();
-    const { errors } = typeCheck(liftedProgram, config, info);
-    const tcEndTime = performance.now();
-    logTime({ label: `Type checked ${absoluteInputFile}`, start: tcStartTime, end: tcEndTime, verbose });
-    if (errors.length === 0)
-        return;
-    if (tc?.strict) {
-        console.error(formatErrors(errors));
-        const hasFatal = errors.some((e) => (e.severity ?? "error") === "error");
-        if (hasFatal)
-            process.exit(1);
-    }
-    else {
-        console.warn(formatErrors(errors, "warning"));
-    }
-}
-// Cached-parse counterpart of `parse()`: same exit-on-failure contract the
-// CLI pipeline expects, but reads through the process-wide parse cache.
-function parseFileOrExit(absPath, config, applyTemplate, contents) {
-    const parseResult = parseAgencyFileCached(absPath, config, applyTemplate);
-    if (!parseResult.success) {
-        if (parseResult.message) {
-            console.error(`Failed to parse Agency program: ${parseResult.message}`);
-        }
-        else {
-            console.error("Failed to parse Agency program.", contents.slice(0, 400));
-        }
-        process.exit(1);
-    }
-    return parseResult.result;
-}
 export function compile(config, inputFile, _outputFile, options) {
-    if (!fs.existsSync(inputFile)) {
-        console.error(`Error: Input file '${inputFile}' not found`);
-        process.exit(1);
-    }
-    const stats = fs.statSync(inputFile);
-    const verbose = config.verbose ?? false;
-    if (stats.isDirectory()) {
-        const files = [...findRecursively(inputFile)].map((f) => f.path);
-        // A directory is many entry points — every .agency file under it. To
-        // avoid recompiling shared dependencies once per entry, build ONE
-        // import closure covering all of them up front and reuse it for every
-        // file. Without this, each sibling entry the previous closure didn't
-        // cover would clear the per-session cache (see ensureCompiledClosure)
-        // and recompile shared deps once per entry. Skipped for:
-        //   - recursive child calls (a symbolTable was threaded in) — those
-        //     aren't real top-level directory compiles; and
-        //   - stdlib dirs, which intentionally compile without a closure (the
-        //     same carve-out ensureCompiledClosure makes for stdlib entries).
-        const absDir = path.resolve(inputFile);
-        const isStdlibDir = absDir === getStdlibDir() || absDir.startsWith(getStdlibDir() + path.sep);
-        if (!options?.symbolTable && !isStdlibDir && files.length > 0) {
-            try {
-                currentClosure = buildCompiledClosure(files.map((f) => path.resolve(f)), config);
-                // The fresh union closure supersedes anything cached for a prior
-                // entry; drop the per-file set so codegen reruns under it.
-                compiledFiles.clear();
-            }
-            catch (e) {
-                if (e instanceof CompileClosureError) {
-                    console.error(e.message);
-                    process.exit(1);
-                }
-                throw e;
-            }
-        }
-        for (const file of files) {
-            compile(config, file, undefined, options);
-        }
-        return null;
-    }
-    const compileStartTime = performance.now();
-    const absoluteInputFile = path.resolve(inputFile);
-    ensureCompiledClosure(absoluteInputFile, config, !!options?.symbolTable, verbose);
-    const ext = options?.ts ? ".ts" : ".js";
-    // Anchor the replacement to the extension so that an absolute path
-    // containing ".agency" as a substring in a parent directory (e.g.
-    // "/Users/me/dev/worksy.agency-init/src/agent.agency") does not get
-    // the first match clobbered. See issue #48.
-    let outputFile = _outputFile || inputFile.replace(/\.agency$/, ext);
-    if (config.outDir && !_outputFile) {
-        const outputDir = path.resolve(config.outDir);
-        if (!fs.existsSync(outputDir)) {
-            fs.mkdirSync(outputDir, { recursive: true });
-        }
-        outputFile = path.join(outputDir, outputFile);
-    }
-    if (compiledFiles.has(absoluteInputFile)) {
-        return outputFile;
-    }
-    compiledFiles.add(absoluteInputFile);
-    const contents = readFile(inputFile);
-    const applyTemplate = !isNonTemplatedStdlib(absoluteInputFile);
-    const parsedProgram = parseFileOrExit(absoluteInputFile, config, applyTemplate, contents);
-    const symbolTableStartTime = performance.now();
-    const symbolTable = options?.symbolTable ?? SymbolTable.build(absoluteInputFile, config);
-    const symbolTableEndTime = performance.now();
-    logTime({ label: `Built symbol table for ${absoluteInputFile}`, start: symbolTableStartTime, end: symbolTableEndTime, verbose });
-    const compilationUnitStartTime = performance.now();
-    const reExportedProgram = resolveReExports(parsedProgram, symbolTable, absoluteInputFile);
-    const resolvedProgram = resolveImports(reExportedProgram, symbolTable, absoluteInputFile, {
-        allowTestImports: options?.allowTestImports ?? false,
-    });
-    // Lift `callback("onX") { ... }` block bodies to top-level defs.
-    // Must run BEFORE buildCompilationUnit and typecheck so the lifted defs
-    // appear in functionDefinitions and get their bodies typechecked.
-    const liftedProgram = liftCallbackBlocks(resolvedProgram);
-    const info = buildCompilationUnit(liftedProgram, symbolTable, absoluteInputFile, contents);
-    const compilationUnitEndTime = performance.now();
-    logTime({ label: `Built compilation unit for ${absoluteInputFile}`, start: compilationUnitStartTime, end: compilationUnitEndTime, verbose });
-    runTypecheck(liftedProgram, config, info, absoluteInputFile, verbose);
-    const imports = getImports(resolvedProgram);
-    for (const importPath of imports) {
-        if (isStdlibImport(importPath) || isPkgImport(importPath))
-            continue;
-        const absPath = resolveAgencyImportPath(importPath, absoluteInputFile);
-        compile(config, absPath, undefined, { ...options, symbolTable });
-    }
-    // Rewrite import paths in the AST using the import strategy
-    const strategy = options?.importStrategy ?? new CompileStrategy({ targetExt: ".js" });
-    const nonAgencyImports = [];
-    liftedProgram.nodes.forEach((node) => {
-        if (node.type !== "importStatement")
-            return;
-        if (isStdlibImport(node.modulePath) || isPkgImport(node.modulePath))
-            return;
-        node.modulePath = strategy.rewriteImport(node.modulePath, absoluteInputFile);
-        if (!node.modulePath.endsWith(".agency")) {
-            nonAgencyImports.push(node.modulePath);
-        }
-    });
-    try {
-        strategy.prepareDependencies(nonAgencyImports, absoluteInputFile);
-    }
-    catch (error) {
-        console.error(error instanceof Error ? error.message : String(error));
-        process.exit(1);
-    }
-    const moduleId = path.relative(process.cwd(), absoluteInputFile);
-    const absoluteOutputFile = path.resolve(outputFile);
-    // Per-module init plan view — derived from the cached closure if we
-    // built one. Modules not in the closure (e.g., out-of-tree stdlib
-    // compiles) fall through to the legacy path with no plan.
-    const initPlan = currentClosure
-        ? initPlanForModule(currentClosure, absoluteInputFile)
-        : undefined;
-    const codegenStartTime = performance.now();
-    const generatedCode = generateTypeScript(liftedProgram, config, info, moduleId, absoluteOutputFile, initPlan);
-    const codegenEndTime = performance.now();
-    logTime({ label: `Generated code for ${absoluteInputFile}`, start: codegenStartTime, end: codegenEndTime, verbose });
-    if (options?.ts) {
-        fs.writeFileSync(outputFile, "// @ts-nocheck\n" + generatedCode, "utf-8");
-    }
-    else {
-        const esbuildStartTime = performance.now();
-        const result = transformSync(generatedCode, {
-            loader: "ts",
-            format: "esm",
-            supported: { "top-level-await": true },
-        });
-        fs.writeFileSync(outputFile, result.code, "utf-8");
-        const esbuildEndTime = performance.now();
-        logTime({ label: `Transformed code for ${absoluteInputFile} with esbuild`, start: esbuildStartTime, end: esbuildEndTime, verbose });
-    }
-    const compileEndTime = performance.now();
-    const timeTaken = `${(compileEndTime - compileStartTime).toFixed(2)}ms`;
-    if (!options?.quiet) {
-        console.log(`${inputFile} → ${outputFile} (in ${timeTaken})`);
-    }
-    return outputFile;
+    return getDefaultSession().compile(config, inputFile, _outputFile, options);
 }
 export async function format(contents, config = {}) {
     // Format path opts out of pattern lowering so the formatter sees the original
@@ -443,8 +208,3 @@ export function run(config, inputFile, outputFile, resumeFile) {
         }
     });
 }
-function logTime({ label, start, end, verbose }) {
-    if (verbose) {
-        console.log(`${label} in ${(end - start).toFixed(2)}ms`);
-    }
-}

package/dist/lib/cli/precompile.d.ts

@@ -1,22 +1,7 @@
 import { AgencyConfig } from "../config.js";
-export type PrecompileGroup = {
-    /** Base-config marker or the local-`agency.json` dir, for error messages. */
-    label: string;
-    config: AgencyConfig;
-    /** Canonical serialization of `config`; groups conflict only when keys differ. */
-    configKey: string;
-    /** Absolute `.agency` entry paths. */
-    files: string[];
-};
-export declare function groupTestSources(baseConfig: AgencyConfig, testJsonFiles: string[]): PrecompileGroup[];
-export declare function findCrossConfigConflicts(groups: {
-    label: string;
-    configKey: string;
-    modules: string[];
-}[]): {
-    module: string;
-    labels: string[];
-}[];
+import { type CompileGroup } from "../compiler/buildSession.js";
+export type { CompileGroup as PrecompileGroup };
+export declare function groupTestSources(baseConfig: AgencyConfig, testJsonFiles: string[]): CompileGroup[];
 export declare function precompileTestSources(baseConfig: AgencyConfig, testJsonFiles: string[], options?: {
     quiet?: boolean;
 }): void;

package/dist/lib/cli/precompile.js

@@ -1,5 +1,6 @@
 /**
- * Precompile pass for the Agency test runner.
+ * Precompile pass for the Agency test runner — a thin adapter over
+ * BuildSession.compileGroups.
  *
  * Historically each test CASE recompiled its `.agency` source (and the
  * source's whole import tree) via `executeNodeAsync` → `compile()` — with
@@ -8,23 +9,16 @@
  * unique source exactly once, up front; the runner then executes test cases
  * with `preferCompiled: true`, which reuses the sibling `.js`.
  *
- * Config grouping: compiled output is config-dependent (the generator bakes
- * config defaults into emitted code), and a test dir may carry a local
- * `agency.json` that `runTestFile` merges over the base config. Sources are
- * therefore grouped by merged config — one union-closure compile for all
- * base-config files, plus one per local-config dir.
- *
- * Cross-config invariant: a sibling `.js` is a single slot per module, so a
- * module reachable from two groups whose configs differ would be
- * last-writer-wins. That is asserted here and fails loudly (no test dir
- * does this today). A graceful fallback (per-case compiles for conflicting
- * files) was rejected: interleaved recompiles rewrite shared siblings
- * mid-run, which is exactly the race this pass removes.
+ * What lives HERE is only what is test-runner-specific: mapping `.test.json`
+ * files to sibling sources, honoring file-level skip/skipOnCI, and merging a
+ * dir-local `agency.json` over the base config. The config grouping
+ * contract, the cross-config single-slot assert, and the per-group compile
+ * loop live in lib/compiler/buildSession.ts.
  */
 import fs from "fs";
 import path from "path";
-import { loadConfig, compileMany } from "./commands.js";
-import { buildCompiledClosure, CompileClosureError, } from "../compiler/compileClosure.js";
+import { loadConfig } from "./commands.js";
+import { createBuildSession, } from "../compiler/buildSession.js";
 const BASE_GROUP_LABEL = "<base config>";
 // File-level skip mirror of runTestFile's check: a `skip: true` (or
 // `skipOnCI: true` under CI) .test.json never runs, so its source must not
@@ -62,12 +56,6 @@ export function groupTestSources(baseConfig, testJsonFiles) {
         const group = (groups[label] ??= {
             label,
             config,
-            // JSON.stringify is order-stable here: every config passes through
-            // AgencyConfigSchema.safeParse (loadConfigSafe), and zod rebuilds the
-            // object in SCHEMA shape order, not input order — so semantically
-            // identical configs always serialize identically. Guarded by the
-            // "configKey is key-order independent" test.
-            configKey: JSON.stringify(config),
             files: [],
         });
         if (!group.files.includes(sourceFile))
@@ -75,51 +63,15 @@ export function groupTestSources(baseConfig, testJsonFiles) {
     }
     return Object.values(groups);
 }
-export function findCrossConfigConflicts(groups) {
-    // Null-prototype: keyed by absolute module paths.
-    const touchedBy = Object.create(null);
-    for (const group of groups) {
-        for (const module of group.modules) {
-            (touchedBy[module] ??= []).push({
-                configKey: group.configKey,
-                label: group.label,
-            });
-        }
-    }
-    const conflicts = [];
-    for (const [module, touches] of Object.entries(touchedBy)) {
-        const distinctKeys = touches
-            .map((t) => t.configKey)
-            .filter((key, i, all) => all.indexOf(key) === i);
-        if (distinctKeys.length > 1) {
-            conflicts.push({ module, labels: touches.map((t) => t.label) });
-        }
-    }
-    return conflicts;
-}
 export function precompileTestSources(baseConfig, testJsonFiles, options) {
     const groups = groupTestSources(baseConfig, testJsonFiles);
-    const withClosures = groups.map((group) => ({
-        group,
-        closure: buildCompiledClosure(group.files, group.config),
-    }));
-    const conflicts = findCrossConfigConflicts(withClosures.map(({ group, closure }) => ({
-        label: group.label,
-        configKey: group.configKey,
-        modules: Object.keys(closure.programs),
-    })));
-    if (conflicts.length > 0) {
-        const lines = conflicts.map((c) => `  ${c.module}\n    reachable from: ${c.labels.join(", ")}`);
-        throw new CompileClosureError("Test sources with differing configs share modules. A module's " +
-            "compiled .js is a single slot, so this would be last-writer-wins. " +
-            "Move the shared module or align the configs:\n" +
-            lines.join("\n"));
-    }
-    for (const { group, closure } of withClosures) {
-        compileMany(group.config, group.files, {
-            closure,
-            quiet: options?.quiet,
-            allowTestImports: true,
-        });
-    }
+    // Fresh session per precompile — a declared delta from the old shared
+    // module globals: the default session no longer inherits precompile's
+    // last-group closure/dedupe state. Safe because test cases run with
+    // `preferCompiled: true` and never re-enter compile(); the old inherited
+    // state was itself a latent staleness hazard.
+    createBuildSession().compileGroups(groups, {
+        quiet: options?.quiet,
+        allowTestImports: true,
+    });
 }

package/dist/lib/cli/precompile.test.js

@@ -2,7 +2,7 @@ import { describe, expect, test } from "vitest";
 import fs from "fs";
 import os from "os";
 import path from "path";
-import { findCrossConfigConflicts, groupTestSources, precompileTestSources, } from "./precompile.js";
+import { groupTestSources, precompileTestSources } from "./precompile.js";
 const TRIVIAL = 'node main() {\n  return "ok"\n}\n';
 const HELPER = 'export def helper(): string {\n  return "shared"\n}\n';
 const IMPORTS_HELPER = 'import { helper } from "../shared/helper.agency"\n\nnode main() {\n  return helper()\n}\n';
@@ -19,31 +19,6 @@ function writeTree(spec) {
     return root;
 }
 const TEST_JSON = JSON.stringify({ tests: [] });
-describe("findCrossConfigConflicts", () => {
-    test("no conflict when groups with the same config share a module", () => {
-        const conflicts = findCrossConfigConflicts([
-            { label: "a", configKey: "{}", modules: ["/shared.agency"] },
-            { label: "b", configKey: "{}", modules: ["/shared.agency"] },
-        ]);
-        expect(conflicts).toEqual([]);
-    });
-    test("conflict when groups with differing configs share a module", () => {
-        const conflicts = findCrossConfigConflicts([
-            { label: "a", configKey: "{}", modules: ["/shared.agency", "/a.agency"] },
-            { label: "b", configKey: '{"verbose":true}', modules: ["/shared.agency"] },
-        ]);
-        expect(conflicts).toHaveLength(1);
-        expect(conflicts[0].module).toBe("/shared.agency");
-        expect(conflicts[0].labels.sort()).toEqual(["a", "b"]);
-    });
-    test("no conflict when differing-config groups touch disjoint modules", () => {
-        const conflicts = findCrossConfigConflicts([
-            { label: "a", configKey: "{}", modules: ["/a.agency"] },
-            { label: "b", configKey: '{"verbose":true}', modules: ["/b.agency"] },
-        ]);
-        expect(conflicts).toEqual([]);
-    });
-});
 describe("groupTestSources", () => {
     test("files without a local agency.json land in one base group", () => {
         const root = writeTree({
@@ -78,7 +53,7 @@ describe("groupTestSources", () => {
         expect(custom.config.verbose).toBe(true);
         expect(custom.config.observability).toBe(true);
         const base = groups.find((g) => !g.label.includes("custom"));
-        expect(base.configKey).not.toBe(custom.configKey);
+        expect(base.config).not.toEqual(custom.config);
     });
     test("file-level skipped test files are excluded", () => {
         const root = writeTree({
@@ -95,28 +70,30 @@ describe("groupTestSources", () => {
         expect(groups).toHaveLength(1);
         expect(groups[0].files).toEqual([path.join(root, "live/main.agency")]);
     });
-    test("configKey is key-order independent", () => {
-        // Same config content, different key order in the two agency.json
-        // files. JSON.stringify would produce different strings; the group
-        // keys must still match so the dirs are config-compatible.
+    test("key-order-different but equal local configs are compatible (zod-normalized keys)", () => {
+        // Two dirs whose agency.json files have the same content in different
+        // key order, sharing an imported module. The session derives config
+        // keys via JSON.stringify, which is only order-stable because
+        // loadConfig routes through zod (schema shape order). If that
+        // normalization ever breaks, the keys diverge and the shared module
+        // trips the cross-config assert — this test is the tripwire.
         const root = writeTree({
+            shared: { "helper.agency": HELPER },
             a: {
-                "main.agency": TRIVIAL,
+                "main.agency": IMPORTS_HELPER,
                 "main.test.json": TEST_JSON,
-                "agency.json": '{"verbose": true, "observability": false}',
+                "agency.json": '{"verbose": false, "observability": true}',
             },
             b: {
-                "main.agency": TRIVIAL,
+                "main.agency": IMPORTS_HELPER,
                 "main.test.json": TEST_JSON,
-                "agency.json": '{"observability": false, "verbose": true}',
+                "agency.json": '{"observability": true, "verbose": false}',
             },
         });
-        const groups = groupTestSources({}, [
+        expect(() => precompileTestSources({}, [
             path.join(root, "a/main.test.json"),
             path.join(root, "b/main.test.json"),
-        ]);
-        expect(groups).toHaveLength(2);
-        expect(groups[0].configKey).toBe(groups[1].configKey);
+        ], { quiet: true })).not.toThrow();
     });
     test("test files without a sibling .agency are excluded", () => {
         const root = writeTree({