@pattern-stack/codegen 0.13.1 → 0.14.1

package/dist/src/cli/index.js

@@ -1073,8 +1073,8 @@ var icons = {
 };
 
 // src/cli/commands/entity.ts
-import fs9 from "fs";
-import path13 from "path";
+import fs10 from "fs";
+import path14 from "path";
 import { Command as Command2, Option as Option2 } from "clipanion";
 
 // src/utils/yaml-loader.ts
@@ -3082,8 +3082,8 @@ function loadEntityFromYaml(filePath) {
 }
 function formatZodErrors(error) {
   return error.errors.map((err) => {
-    const path34 = err.path.join(".");
-    const location = path34 ? `at '${path34}'` : "at root";
+    const path36 = err.path.join(".");
+    const location = path36 ? `at '${path36}'` : "at root";
     return `${err.message} ${location}`;
   });
 }
@@ -3684,8 +3684,8 @@ function collectEntitySurfaces(entities) {
   return surfaces;
 }
 function resolveImportRef(ref, opts) {
-  const { path: path34, exportName } = parseImportRef(ref);
-  const file = resolveModuleFile(path34, opts);
+  const { path: path36, exportName } = parseImportRef(ref);
+  const file = resolveModuleFile(path36, opts);
   if (!file) {
     return { status: "module-not-found", resolvedFrom: opts.sourceRoot };
   }
@@ -3905,19 +3905,19 @@ function findCircularDependencies(graph) {
   const cycles = [];
   const visited = /* @__PURE__ */ new Set();
   const recursionStack = /* @__PURE__ */ new Set();
-  function dfs(node, path34) {
+  function dfs(node, path36) {
     visited.add(node);
     recursionStack.add(node);
     const outgoingEdges = graph.edges.filter((e) => e.from === node);
     for (const edge of outgoingEdges) {
       if (!visited.has(edge.to)) {
-        dfs(edge.to, [...path34, edge.to]);
+        dfs(edge.to, [...path36, edge.to]);
       } else if (recursionStack.has(edge.to)) {
-        const cycleStart = path34.indexOf(edge.to);
+        const cycleStart = path36.indexOf(edge.to);
         if (cycleStart !== -1) {
-          cycles.push([...path34.slice(cycleStart), edge.to]);
+          cycles.push([...path36.slice(cycleStart), edge.to]);
         } else {
-          cycles.push([...path34, edge.to]);
+          cycles.push([...path36, edge.to]);
         }
       }
     }
@@ -4514,8 +4514,8 @@ function suggestTransitiveRelationships(graph, options) {
   for (const [entityName, entity] of graph.entities) {
     if (shouldExcludeEntity(entityName, opts)) continue;
     const paths = findTransitivePaths(graph, entityName, opts);
-    for (const path34 of paths) {
-      suggestions.push(createSuggestion(path34));
+    for (const path36 of paths) {
+      suggestions.push(createSuggestion(path36));
     }
   }
   return suggestions;
@@ -4546,7 +4546,7 @@ function findTransitivePaths(graph, sourceEntity, opts) {
   while (queue.length > 0) {
     const current = queue.shift();
     if (!current) continue;
-    const { entity, depth, path: path34, visited } = current;
+    const { entity, depth, path: path36, visited } = current;
     if (depth >= opts.maxDepth) continue;
     const currentEntity = graph.entities.get(entity);
     if (!currentEntity) continue;
@@ -4557,7 +4557,7 @@ function findTransitivePaths(graph, sourceEntity, opts) {
       if (shouldExcludeEntity(target, opts)) continue;
       if (visited.has(target)) continue;
       const newPath = [
-        ...path34,
+        ...path36,
         {
           via: entity,
           relationship: relName,
@@ -4625,15 +4625,15 @@ function generateYamlSnippet(name, target, throughPath) {
     target: ${target}
     through: "${throughPath}"`;
 }
-function createSuggestion(path34) {
-  const pathDescription = [path34.source, ...path34.hops.map((h) => h.via), path34.target].join(" -> ");
+function createSuggestion(path36) {
+  const pathDescription = [path36.source, ...path36.hops.map((h) => h.via), path36.target].join(" -> ");
   return {
     severity: "info",
     type: "transitive_suggestion",
-    entity: path34.source,
+    entity: path36.source,
     message: `Potential transitive relationship: ${pathDescription}`,
-    suggestion: `Add "${path34.suggestedName}" relationship via "${path34.throughPath}"`,
-    path: path34
+    suggestion: `Add "${path36.suggestedName}" relationship via "${path36.throughPath}"`,
+    path: path36
   };
 }
 
@@ -6279,6 +6279,24 @@ import path8 from "path";
 // src/cli/shared/subsystem-detect.ts
 import fs4 from "fs";
 import path6 from "path";
+
+// src/cli/shared/runtime-import.ts
+var PACKAGE = "@pattern-stack/codegen";
+function resolveRuntimeMode(config) {
+  return config?.runtime === "vendored" ? "vendored" : "package";
+}
+function subsystemsImport(mode, subsystem) {
+  if (mode === "vendored") {
+    return subsystem ? `@shared/subsystems/${subsystem}` : "@shared/subsystems";
+  }
+  return `${PACKAGE}/subsystems`;
+}
+function runtimeImport(mode, relpath) {
+  const clean = relpath.replace(/^\/+/, "");
+  return mode === "vendored" ? `@shared/${clean}` : `${PACKAGE}/runtime/${clean}`;
+}
+
+// src/cli/shared/subsystem-detect.ts
 var SUBSYSTEMS = [
   {
     name: "events",
@@ -6475,6 +6493,36 @@ async function detectInstalledSubsystems(ctx) {
   const states = await detectSubsystemStatesImpl(ctx);
   return states.filter((s) => s.status === "installed");
 }
+function configuredSubsystemNames(config) {
+  const subsystems = config?.subsystems;
+  const raw = subsystems?.install;
+  if (!Array.isArray(raw)) return [];
+  const known = new Set(KNOWN_NAMES);
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const entry of raw) {
+    if (typeof entry !== "string") continue;
+    if (!known.has(entry)) continue;
+    const name = entry;
+    if (seen.has(name)) continue;
+    seen.add(name);
+    out.push(name);
+  }
+  return out;
+}
+function configuredInstalledSubsystems(config) {
+  return configuredSubsystemNames(config).map((name) => {
+    const desc3 = SUBSYSTEMS.find((s) => s.name === name);
+    const cfg = config?.[name];
+    const backend = typeof cfg?.backend === "string" ? cfg.backend : desc3?.defaultBackend ?? "drizzle";
+    return {
+      name,
+      path: `@pattern-stack/codegen/subsystems#${name}`,
+      backend,
+      status: "installed"
+    };
+  });
+}
 
 // src/cli/shared/subsystems-path.ts
 import path7 from "path";
@@ -6523,55 +6571,55 @@ function quoteBullmqDomainOpts(input) {
   return `{ ${parts.join(", ")} }`;
 }
 var COMPOSERS = {
-  events: ({ subsystemsRel, cfg }) => {
+  events: ({ moduleImport, cfg }) => {
     const backend = cfg?.backend ?? "drizzle";
     const multiTenant = Boolean(cfg?.multi_tenant);
     return {
       imports: [
-        `import { EventsModule } from '${subsystemsRel}/events/events.module';`
+        `import { EventsModule } from '${moduleImport("events", "events.module")}';`
       ],
       calls: [
         `	EventsModule.forRoot(${quoteOpts({ backend, multiTenant })}),`
       ]
     };
   },
-  jobs: ({ subsystemsRel, cfg }) => {
+  jobs: ({ moduleImport, cfg }) => {
     const backend = cfg?.backend ?? "drizzle";
     const multiTenant = Boolean(cfg?.multi_tenant);
     const workerMode = (cfg?.worker_mode ?? "standalone").trim();
     const imports = [
-      `import { JobsDomainModule } from '${subsystemsRel}/jobs/jobs-domain.module';`
+      `import { JobsDomainModule } from '${moduleImport("jobs", "jobs-domain.module")}';`
     ];
     const bullExt = backend === "bullmq" ? cfg?.extensions?.bullmq : void 0;
     const domainOpts = quoteBullmqDomainOpts({ backend, multiTenant, bullExt });
     const calls = [`	JobsDomainModule.forRoot(${domainOpts}),`];
     if (workerMode === "embedded") {
       imports.push(
-        `import { JobWorkerModule } from '${subsystemsRel}/jobs/job-worker.module';`
+        `import { JobWorkerModule } from '${moduleImport("jobs", "job-worker.module")}';`
       );
       const workerOpts = backend === "bullmq" ? `{ mode: 'embedded', backend: 'bullmq'${bullExt ? `, domainModuleExtensions: { bullmq: ${jsonToTs(bullExt)} }` : ""} }` : `{ mode: 'embedded' }`;
       calls.push(`	JobWorkerModule.forRoot(${workerOpts}),`);
     }
     return { imports, calls };
   },
-  bridge: ({ subsystemsRel, cfg }) => {
+  bridge: ({ moduleImport, cfg }) => {
     const backend = cfg?.backend ?? "drizzle";
     const multiTenant = Boolean(cfg?.multi_tenant);
     return {
       imports: [
-        `import { BridgeModule } from '${subsystemsRel}/bridge/bridge.module';`
+        `import { BridgeModule } from '${moduleImport("bridge", "bridge.module")}';`
       ],
       calls: [
         `	BridgeModule.forRoot(${quoteOpts({ backend, multiTenant })}),`
       ]
     };
   },
-  integration: ({ subsystemsRel, cfg }) => {
+  integration: ({ moduleImport, cfg }) => {
     const backend = cfg?.backend ?? "drizzle";
     const multiTenant = Boolean(cfg?.multi_tenant);
     return {
       imports: [
-        `import { IntegrationModule } from '${subsystemsRel}/integration/integration.module';`
+        `import { IntegrationModule } from '${moduleImport("integration", "integration.module")}';`
       ],
       calls: [
         `	IntegrationModule.forRoot(${quoteOpts({ backend, multiTenant })}),`
@@ -6579,6 +6627,13 @@ var COMPOSERS = {
     };
   }
 };
+var PACKAGE2 = "@pattern-stack/codegen";
+function makeModuleImport(mode, subsystemsRel) {
+  if (mode === "vendored") {
+    return (subsystem, moduleBasename) => `${subsystemsRel}/${subsystem}/${moduleBasename}`;
+  }
+  return (subsystem) => subsystem === "events" ? `${PACKAGE2}/subsystems` : `${PACKAGE2}/runtime/subsystems/${subsystem}/index`;
+}
 var COMPOSABLE_ORDER = ["events", "jobs", "bridge", "integration"];
 var HEADER3 = `// AUTO-GENERATED by @pattern-stack/codegen. DO NOT EDIT.
 // Subsystem composition barrel \u2014 reflects \`subsystems.install\` in
@@ -6593,7 +6648,8 @@ var HEADER3 = `// AUTO-GENERATED by @pattern-stack/codegen. DO NOT EDIT.
 // Regenerated by every \`codegen entity new\` / \`codegen subsystem install\`.
 
 `;
-function buildSubsystemBarrel(installed, config, subsystemsRel) {
+function buildSubsystemBarrel(installed, config, subsystemsRel, mode = "vendored") {
+  const moduleImport = makeModuleImport(mode, subsystemsRel);
   const actable = installed.filter((i) => i.status !== "incomplete");
   const installedNames = new Set(actable.map((i) => i.name));
   const emitted = [];
@@ -6608,7 +6664,7 @@ function buildSubsystemBarrel(installed, config, subsystemsRel) {
       continue;
     }
     const cfg = config?.[name] ?? void 0;
-    const out = composer({ subsystemsRel, cfg });
+    const out = composer({ moduleImport, cfg });
     allImports.push(...out.imports);
     allCalls.push(...out.calls);
     emitted.push(name);
@@ -6629,7 +6685,10 @@ ${allCalls.join("\n")}
 async function regenerateSubsystemBarrel(opts) {
   const { ctx, dryRun = false } = opts;
   const generatedDir = opts.generatedDir ?? resolveGeneratedDir(ctx);
-  const installed = await detectInstalledSubsystems(ctx);
+  const mode = resolveRuntimeMode(ctx.config);
+  const installed = mode === "package" ? configuredInstalledSubsystems(
+    ctx.config
+  ) : await detectInstalledSubsystems(ctx);
   const subsystemsAbs = resolveSubsystemsRoot(ctx);
   const barrelAbs = path8.resolve(generatedDir, "subsystems.ts");
   let subsystemsRel = path8.relative(path8.dirname(barrelAbs), subsystemsAbs).split(path8.sep).join("/");
@@ -6637,7 +6696,8 @@ async function regenerateSubsystemBarrel(opts) {
   const { content, emitted, skipped } = buildSubsystemBarrel(
     installed,
     ctx.config,
-    subsystemsRel
+    subsystemsRel,
+    mode
   );
   let written = false;
   if (!dryRun) {
@@ -6654,11 +6714,101 @@ async function regenerateSubsystemBarrel(opts) {
   };
 }
 
-// src/cli/shared/bridge-registry-generator.ts
+// src/cli/shared/subsystem-schema-generator.ts
 import fs6 from "fs";
 import path9 from "path";
-import ts2 from "typescript";
+var PACKAGE3 = "@pattern-stack/codegen";
+var SCHEMA_SYMBOLS = {
+  events: ["domainEvents"],
+  jobs: [
+    "jobs",
+    "jobRuns",
+    "jobSteps",
+    "jobRunStatusEnum",
+    "jobStepKindEnum",
+    "jobStepStatusEnum",
+    "collisionModeEnum",
+    "replayFromEnum",
+    "parentClosePolicyEnum",
+    "waitKindEnum",
+    "triggerSourceEnum"
+  ],
+  bridge: ["bridgeDelivery", "bridgeDeliveryStatusEnum"],
+  integration: [
+    "integrationSubscriptions",
+    "integrationRuns",
+    "integrationRunItems",
+    "integrationRunDirectionEnum",
+    "integrationRunActionEnum",
+    "integrationRunStatusEnum",
+    "integrationRunItemOperationEnum",
+    "integrationRunItemStatusEnum"
+  ]
+};
+var SCHEMA_ORDER = ["events", "jobs", "bridge", "integration"];
 var HEADER4 = `// AUTO-GENERATED by @pattern-stack/codegen. Do not edit.
+// Subsystem Drizzle schema barrel \u2014 re-exports the tables + pgEnums of every
+// installed subsystem so drizzle-kit emits their CREATE TABLE / CREATE TYPE.
+//
+// Fold into your drizzle-kit schema entrypoint once, alongside the entity
+// schema barrel:
+//
+//   // src/schema.ts
+//   export * from './generated/schema';            // entity tables
+//   export * from './generated/subsystems-schema'; // subsystem tables + enums
+//
+// Regenerated by every \`codegen entity new\` / \`codegen subsystem install\`.
+
+`;
+function schemaImportFor(mode, subsystem, subsystemsRel) {
+  return mode === "vendored" ? `${subsystemsRel}/${subsystem}` : `${PACKAGE3}/runtime/subsystems/${subsystem}/index`;
+}
+function buildSubsystemSchemaBarrel(installed, subsystemsRel, mode) {
+  const actable = installed.filter((i) => i.status !== "incomplete");
+  const installedNames = new Set(actable.map((i) => i.name));
+  const emitted = [];
+  const lines = [];
+  for (const name of SCHEMA_ORDER) {
+    if (!installedNames.has(name)) continue;
+    const symbols = SCHEMA_SYMBOLS[name];
+    if (!symbols || symbols.length === 0) continue;
+    const importSpec = schemaImportFor(mode, name, subsystemsRel);
+    lines.push(`export { ${symbols.join(", ")} } from '${importSpec}';`);
+    emitted.push(name);
+  }
+  const body = lines.length === 0 ? "export {};\n" : lines.join("\n") + "\n";
+  return { content: HEADER4 + body, emitted };
+}
+async function regenerateSubsystemSchemaBarrel(opts) {
+  const { ctx, dryRun = false } = opts;
+  const generatedDir = opts.generatedDir ?? resolveGeneratedDir(ctx);
+  const mode = resolveRuntimeMode(ctx.config);
+  const installed = mode === "package" ? configuredInstalledSubsystems(
+    ctx.config
+  ) : await detectInstalledSubsystems(ctx);
+  const subsystemsAbs = resolveSubsystemsRoot(ctx);
+  const barrelAbs = path9.resolve(generatedDir, "subsystems-schema.ts");
+  let subsystemsRel = path9.relative(path9.dirname(barrelAbs), subsystemsAbs).split(path9.sep).join("/");
+  if (!subsystemsRel.startsWith(".")) subsystemsRel = "./" + subsystemsRel;
+  const { content, emitted } = buildSubsystemSchemaBarrel(
+    installed,
+    subsystemsRel,
+    mode
+  );
+  let written = false;
+  if (!dryRun) {
+    fs6.mkdirSync(path9.dirname(barrelAbs), { recursive: true });
+    fs6.writeFileSync(barrelAbs, content);
+    written = true;
+  }
+  return { schemaBarrel: barrelAbs, emitted, content, written };
+}
+
+// src/cli/shared/bridge-registry-generator.ts
+import fs7 from "fs";
+import path10 from "path";
+import ts2 from "typescript";
+var HEADER5 = `// AUTO-GENERATED by @pattern-stack/codegen. Do not edit.
 // Run \`codegen entity new --all\` to refresh.
 `;
 var DuplicateTriggerError = class extends Error {
@@ -6716,12 +6866,12 @@ var UnknownTriggerEventError = class extends Error {
   name = "UnknownTriggerEventError";
 };
 function findHandlerFiles(dir) {
-  if (!fs6.existsSync(dir)) return [];
+  if (!fs7.existsSync(dir)) return [];
   const out = [];
-  for (const entry of fs6.readdirSync(dir, { withFileTypes: true })) {
+  for (const entry of fs7.readdirSync(dir, { withFileTypes: true })) {
     if (entry.name.startsWith(".")) continue;
     if (entry.name === "node_modules" || entry.name === "generated") continue;
-    const full = path9.join(dir, entry.name);
+    const full = path10.join(dir, entry.name);
     if (entry.isDirectory()) {
       out.push(...findHandlerFiles(full));
     } else if (entry.isFile() && entry.name.endsWith(".ts") && !entry.name.endsWith(".d.ts")) {
@@ -6784,7 +6934,7 @@ function scanHandlerFiles(handlersDir) {
   const files = findHandlerFiles(handlersDir);
   const out = [];
   for (const filePath of files) {
-    const text2 = fs6.readFileSync(filePath, "utf8");
+    const text2 = fs7.readFileSync(filePath, "utf8");
     const sourceFile = ts2.createSourceFile(
       filePath,
       text2,
@@ -6799,9 +6949,9 @@ function scanHandlerFiles(handlersDir) {
 }
 function readKnownEventTypes(eventsGeneratedDir) {
   if (!eventsGeneratedDir) return [];
-  const registryPath = path9.join(eventsGeneratedDir, "registry.ts");
-  if (!fs6.existsSync(registryPath)) return [];
-  const text2 = fs6.readFileSync(registryPath, "utf8");
+  const registryPath = path10.join(eventsGeneratedDir, "registry.ts");
+  if (!fs7.existsSync(registryPath)) return [];
+  const text2 = fs7.readFileSync(registryPath, "utf8");
   const out = /* @__PURE__ */ new Set();
   const re = /^\s*'([a-zA-Z0-9_.-]+)':\s*\{/gm;
   let m;
@@ -6813,9 +6963,9 @@ function readKnownEventTypes(eventsGeneratedDir) {
 function readEventTiers(eventsGeneratedDir) {
   const out = /* @__PURE__ */ new Map();
   if (!eventsGeneratedDir) return out;
-  const registryPath = path9.join(eventsGeneratedDir, "registry.ts");
-  if (!fs6.existsSync(registryPath)) return out;
-  const text2 = fs6.readFileSync(registryPath, "utf8");
+  const registryPath = path10.join(eventsGeneratedDir, "registry.ts");
+  if (!fs7.existsSync(registryPath)) return out;
+  const text2 = fs7.readFileSync(registryPath, "utf8");
   const re = /'([a-zA-Z0-9_.-]+)':\s*\{[^}]*?tier:\s*'(domain|audit)'/g;
   let m;
   while ((m = re.exec(text2)) !== null) {
@@ -6872,7 +7022,7 @@ function validateAgainstEventRegistry(triggers, knownEventTypes) {
 }
 function buildBridgeRegistryContent(triggers) {
   const chunks = [];
-  chunks.push(HEADER4);
+  chunks.push(HEADER5);
   chunks.push("");
   chunks.push(`import type { BridgeRegistry } from '../bridge.protocol';`);
   chunks.push("");
@@ -6910,11 +7060,11 @@ function buildBridgeRegistryContent(triggers) {
 var OUTPUT_FILE_NAME = "registry.ts";
 async function generateBridgeRegistry(opts) {
   const { handlersDir, eventsGeneratedDir, outputDir, dryRun = false } = opts;
-  const bridgeProtocolPath = path9.resolve(outputDir, "..", "bridge.protocol.ts");
-  if (!fs6.existsSync(bridgeProtocolPath)) {
-    const strayPath = path9.join(outputDir, OUTPUT_FILE_NAME);
-    if (!dryRun && fs6.existsSync(strayPath)) {
-      fs6.rmSync(strayPath);
+  const bridgeProtocolPath = path10.resolve(outputDir, "..", "bridge.protocol.ts");
+  if (!fs7.existsSync(bridgeProtocolPath)) {
+    const strayPath = path10.join(outputDir, OUTPUT_FILE_NAME);
+    if (!dryRun && fs7.existsSync(strayPath)) {
+      fs7.rmSync(strayPath);
     }
     return {
       outputDir,
@@ -6935,13 +7085,13 @@ async function generateBridgeRegistry(opts) {
   const content = buildBridgeRegistryContent(triggers);
   const file = {
     name: OUTPUT_FILE_NAME,
-    outputPath: path9.join(outputDir, OUTPUT_FILE_NAME),
+    outputPath: path10.join(outputDir, OUTPUT_FILE_NAME),
     content
   };
   let written = false;
   if (!dryRun) {
-    fs6.mkdirSync(outputDir, { recursive: true });
-    fs6.writeFileSync(file.outputPath, file.content);
+    fs7.mkdirSync(outputDir, { recursive: true });
+    fs7.writeFileSync(file.outputPath, file.content);
     written = true;
   }
   const eventTypeCount = new Set(triggers.map((t) => t.event)).size;
@@ -6957,8 +7107,8 @@ async function generateBridgeRegistry(opts) {
 }
 
 // src/cli/shared/orchestration-generator.ts
-import fs7 from "fs";
-import path10 from "path";
+import fs8 from "fs";
+import path11 from "path";
 var OrchestrationEmissionError = class extends Error {
   constructor(issueType, patternName, message) {
     super(`[${issueType}] ${patternName}: ${message}`);
@@ -6969,7 +7119,7 @@ var OrchestrationEmissionError = class extends Error {
   patternName;
   name = "OrchestrationEmissionError";
 };
-var HEADER5 = `// AUTO-GENERATED by @pattern-stack/codegen. Do not edit.
+var HEADER6 = `// AUTO-GENERATED by @pattern-stack/codegen. Do not edit.
 // See ADR-032 \u2014 Orchestration Patterns.
 `;
 function splitWords(str) {
@@ -7133,7 +7283,7 @@ function buildTokensTs(pattern) {
     typeImports.push({ specifier: reg.valueTypeImport, name: reg.valueType });
   }
   const lines = [];
-  lines.push(HEADER5.trimEnd());
+  lines.push(HEADER6.trimEnd());
   lines.push("");
   for (const i of emitTypeImports(typeImports)) lines.push(i);
   lines.push("");
@@ -7166,7 +7316,7 @@ function buildProvidersTs(pattern) {
   }
   const optsType = forRootOptionsTypeName(pattern);
   const lines = [];
-  lines.push(HEADER5.trimEnd());
+  lines.push(HEADER6.trimEnd());
   lines.push("");
   lines.push(`import type { Provider } from '@nestjs/common';`);
   for (const i of emitTypeImports(typeImports)) lines.push(i);
@@ -7233,7 +7383,7 @@ function buildDispatcherTs(pattern) {
   const tokenValues = registries.map(({ names: names2 }) => names2.tokenConst);
   const mapTypes = registries.map(({ names: names2 }) => names2.mapType);
   const lines = [];
-  lines.push(HEADER5.trimEnd());
+  lines.push(HEADER6.trimEnd());
   lines.push("");
   lines.push(`import { Inject, Injectable } from '@nestjs/common';`);
   for (const i of emitTypeImports(typeImports)) lines.push(i);
@@ -7307,7 +7457,7 @@ function buildModuleTs(pattern) {
   }
   const tokenValues = registries.map(({ names: names2 }) => names2.tokenConst);
   const lines = [];
-  lines.push(HEADER5.trimEnd());
+  lines.push(HEADER6.trimEnd());
   lines.push("");
   lines.push(`import { type DynamicModule, Module } from '@nestjs/common';`);
   for (const i of emitTypeImports(typeImports)) lines.push(i);
@@ -7341,7 +7491,7 @@ function buildModuleTs(pattern) {
 }
 function buildIndexTs(pattern) {
   const lines = [];
-  lines.push(HEADER5.trimEnd());
+  lines.push(HEADER6.trimEnd());
   lines.push("");
   lines.push(`export * from './tokens.js';`);
   lines.push(`export * from './dispatcher.js';`);
@@ -7352,7 +7502,7 @@ function buildIndexTs(pattern) {
 }
 function buildRootBarrelTs(patterns) {
   const lines = [];
-  lines.push(HEADER5.trimEnd());
+  lines.push(HEADER6.trimEnd());
   lines.push("");
   if (patterns.length === 0) {
     lines.push("// No orchestration patterns registered.");
@@ -7370,11 +7520,11 @@ function buildRootBarrelTs(patterns) {
 function buildPatternFiles(pattern, outputRoot) {
   assertEmittable(pattern);
   const slug = toKebabCase2(pattern.name);
-  const outputDir = path10.join(outputRoot, slug);
+  const outputDir = path11.join(outputRoot, slug);
   const make = (name, content) => ({
     name,
-    outputPath: path10.join(outputDir, name),
-    relativePath: path10.join(slug, name),
+    outputPath: path11.join(outputDir, name),
+    relativePath: path11.join(slug, name),
     content
   });
   const files = [
@@ -7402,21 +7552,21 @@ function generateOrchestrationModules(opts) {
   }
   const rootBarrel = {
     name: "index.ts",
-    outputPath: path10.join(outputRoot, "index.ts"),
+    outputPath: path11.join(outputRoot, "index.ts"),
     relativePath: "index.ts",
     content: buildRootBarrelTs(patterns)
   };
   allFiles.push(rootBarrel);
   let written = false;
   if (!dryRun && patterns.length > 0) {
-    fs7.mkdirSync(outputRoot, { recursive: true });
+    fs8.mkdirSync(outputRoot, { recursive: true });
     for (const r of perPattern) {
-      fs7.mkdirSync(r.outputDir, { recursive: true });
+      fs8.mkdirSync(r.outputDir, { recursive: true });
       for (const f of r.files) {
-        fs7.writeFileSync(f.outputPath, f.content);
+        fs8.writeFileSync(f.outputPath, f.content);
       }
     }
-    fs7.writeFileSync(rootBarrel.outputPath, rootBarrel.content);
+    fs8.writeFileSync(rootBarrel.outputPath, rootBarrel.content);
     written = true;
   }
   return {
@@ -7428,8 +7578,8 @@ function generateOrchestrationModules(opts) {
 }
 
 // src/cli/shared/event-codegen-generator.ts
-import fs8 from "fs";
-import path11 from "path";
+import fs9 from "fs";
+import path12 from "path";
 
 // src/parser/load-events.ts
 import { basename as basename2, resolve as resolve4 } from "path";
@@ -7559,7 +7709,7 @@ function isEventFieldType(s) {
 }
 
 // src/cli/shared/event-codegen-generator.ts
-var HEADER6 = `// AUTO-GENERATED by @pattern-stack/codegen. Do not edit.
+var HEADER7 = `// AUTO-GENERATED by @pattern-stack/codegen. Do not edit.
 // Run \`codegen entity new --all\` to refresh.
 `;
 function toCamelCase2(input) {
@@ -7613,7 +7763,7 @@ function aggregateTypeLiteral(ev) {
 function collectEntityEvents(entitiesDir) {
   const events = [];
   const issues = [];
-  if (!fs8.existsSync(entitiesDir)) {
+  if (!fs9.existsSync(entitiesDir)) {
     return { events, issues };
   }
   const files = findYamlFiles(entitiesDir);
@@ -7657,7 +7807,7 @@ function mergeEvents(topLevel, entitySugar) {
 function collectMergedEvents(opts) {
   const { entitiesDir, eventsDir } = opts;
   const entityNames = [];
-  if (fs8.existsSync(entitiesDir)) {
+  if (fs9.existsSync(entitiesDir)) {
     const entityFiles = findYamlFiles(entitiesDir);
     for (const f of entityFiles) {
       const result = loadEntityFromYaml(f);
@@ -7680,7 +7830,7 @@ function collectMergedEvents(opts) {
 function buildTypesContent(events) {
   const sorted = [...events].sort((a, b) => a.type.localeCompare(b.type));
   if (sorted.length === 0) {
-    return HEADER6 + `
+    return HEADER7 + `
 import type { DomainEvent } from '../event-bus.protocol';
 
 export type AppDomainEvent = never;
@@ -7691,7 +7841,7 @@ export type PayloadOfType<T extends EventTypeName> = DomainEvent['payload'];
 `;
   }
   const chunks = [];
-  chunks.push(HEADER6);
+  chunks.push(HEADER7);
   chunks.push("");
   chunks.push(`import type { DomainEvent } from '../event-bus.protocol';`);
   chunks.push("");
@@ -7739,7 +7889,7 @@ export type PayloadOfType<T extends EventTypeName> = DomainEvent['payload'];
 function buildSchemasContent(events) {
   const sorted = [...events].sort((a, b) => a.type.localeCompare(b.type));
   if (sorted.length === 0) {
-    return HEADER6 + `
+    return HEADER7 + `
 import { z } from 'zod';
 import type { EventTypeName } from './types';
 
@@ -7747,7 +7897,7 @@ export const eventPayloadSchemas = {} as Record<EventTypeName, z.ZodType>;
 `;
   }
   const chunks = [];
-  chunks.push(HEADER6);
+  chunks.push(HEADER7);
   chunks.push("");
   chunks.push(`import { z } from 'zod';`);
   chunks.push(`import type { EventTypeName } from './types';`);
@@ -7802,7 +7952,7 @@ var REGISTRY_GETTER = [
 function buildRegistryContent(events) {
   const sorted = [...events].sort((a, b) => a.type.localeCompare(b.type));
   const chunks = [];
-  chunks.push(HEADER6);
+  chunks.push(HEADER7);
   chunks.push("");
   chunks.push(`import type { EventTypeName } from './types';`);
   chunks.push("");
@@ -7982,10 +8132,10 @@ export class TypedEventBus {
 }
 `;
 function buildBusContent(_events) {
-  return HEADER6 + "\n" + BUS_BODY;
+  return HEADER7 + "\n" + BUS_BODY;
 }
 function buildIndexContent(_events) {
-  return HEADER6 + `
+  return HEADER7 + `
 export * from './types';
 export * from './schemas';
 export * from './registry';
@@ -8014,15 +8164,15 @@ async function generateEventCodegen(opts) {
   };
   const files = OUTPUT_FILE_NAMES.map((name) => ({
     name,
-    outputPath: path11.join(outputDir, name),
+    outputPath: path12.join(outputDir, name),
     content: builders[name](merged)
   }));
   const hasError = issues.some((i) => i.severity === "error");
   let written = false;
   if (!dryRun && !hasError) {
-    fs8.mkdirSync(outputDir, { recursive: true });
+    fs9.mkdirSync(outputDir, { recursive: true });
     for (const file of files) {
-      fs8.writeFileSync(file.outputPath, file.content);
+      fs9.writeFileSync(file.outputPath, file.content);
     }
     written = true;
   }
@@ -8105,163 +8255,18 @@ function validateEntityEmits(entities, events) {
 }
 
 // src/cli/shared/provider-module-generator.ts
-import { existsSync as existsSync9, mkdirSync as mkdirSync2, readFileSync as readFileSync7, statSync as statSync5, writeFileSync as writeFileSync2 } from "fs";
-import { dirname, isAbsolute as isAbsolute2, join as join11, resolve as resolve5 } from "path";
-function providerPascalCase(slug) {
-  return slug.split("-").filter(Boolean).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
-}
-function providerConstantCase(slug) {
-  return slug.replace(/-/g, "_").toUpperCase();
-}
-function providerModuleBanner(sourceYaml) {
-  return `// @generated by @pattern-stack/codegen from ${sourceYaml} \u2014 DO NOT EDIT.
-// Hand edits are overwritten on re-emit. Regenerate with \`bun run codegen\`. To change this provider, edit its \`definitions/providers/*.yaml\`.`;
-}
-function generateProviderModule(def, sourceYaml) {
-  const { slug } = def;
-  const Pascal = providerPascalCase(slug);
-  const CONST = providerConstantCase(slug);
-  const strategy = parseImportRef(def.auth.strategy);
-  const client = parseImportRef(def.client.class);
-  const strategyToken = `${CONST}_AUTH_STRATEGY`;
-  const clientToken = `${CONST}_CLIENT`;
-  const surfaces = def.surfaces.join(", ");
-  const title = def.display_name ? `${def.display_name} (\`${slug}\`)` : `\`${slug}\``;
-  return `${providerModuleBanner(sourceYaml)}
-/**
- * Provider module for ${title}.
- *
- * Surfaces: ${surfaces}.
- *
- * Wires the declared auth strategy and API client under the provider-specific
- * DI tokens \`${strategyToken}\` and \`${clientToken}\`. Per the auth subsystem
- * contract, strategies are registered under provider-specific tokens rather
- * than a single \`AUTH_STRATEGY\`. Registry aggregation (RFC-0001 \xA73) is
- * emitted by a later codegen step.
- */
-import { Module } from '@nestjs/common';
-import { ${strategy.exportName} } from '${strategy.path}';
-import { ${client.exportName} } from '${client.path}';
-
-/** DI token for the \`${slug}\` provider's auth strategy. */
-export const ${strategyToken} = Symbol('${strategyToken}');
-/** DI token for the \`${slug}\` provider's API client. */
-export const ${clientToken} = Symbol('${clientToken}');
-
-@Module({
-  providers: [
-    ${strategy.exportName},
-    ${client.exportName},
-    { provide: ${strategyToken}, useExisting: ${strategy.exportName} },
-    { provide: ${clientToken}, useExisting: ${client.exportName} },
-  ],
-  exports: [
-    ${strategy.exportName},
-    ${client.exportName},
-    ${strategyToken},
-    ${clientToken},
-  ],
-})
-export class ${Pascal}ProviderModule {}
-`;
-}
-function resolveTsconfigAliases(consumerRoot) {
-  const tsconfigPath = join11(consumerRoot, "tsconfig.json");
-  if (!existsSync9(tsconfigPath)) return null;
-  let parsed;
-  try {
-    parsed = JSON.parse(stripJsonComments(readFileSync7(tsconfigPath, "utf-8")));
-  } catch {
-    return null;
-  }
-  const compilerOptions = parsed.compilerOptions ?? {};
-  const baseUrl = compilerOptions.baseUrl ?? ".";
-  const sourceRoot = isAbsolute2(baseUrl) ? baseUrl : resolve5(consumerRoot, baseUrl);
-  const aliases = {};
-  for (const [pattern, targets] of Object.entries(compilerOptions.paths ?? {})) {
-    if (!Array.isArray(targets) || targets.length === 0) continue;
-    const aliasKey = pattern.replace(/\/\*$/, "");
-    const target = targets[0].replace(/\/\*$/, "");
-    aliases[aliasKey] = isAbsolute2(target) ? target : resolve5(sourceRoot, target);
-  }
-  return { sourceRoot, aliases };
-}
-function stripJsonComments(input) {
-  return input.replace(/\/\*[\s\S]*?\*\//g, "").replace(/(^|[^:])\/\/.*$/gm, "$1");
-}
-function generateProviderModules(opts) {
-  const base = {
-    providersDir: opts.providersDir,
-    skipped: false,
-    written: [],
-    loadFailures: [],
-    issues: []
-  };
-  if (!existsSync9(opts.providersDir) || !statSync5(opts.providersDir).isDirectory()) {
-    return { ...base, skipped: true };
-  }
-  const files = findYamlFiles(opts.providersDir);
-  if (files.length === 0) return { ...base, skipped: true };
-  const { successes, failures } = loadProvidersFromYaml(files);
-  const loaded = successes.map((s) => ({
-    definition: s.definition,
-    filePath: s.filePath
-  }));
-  const issues = failures.map((f) => ({
-    severity: "error",
-    type: "provider_load_failed",
-    message: `${f.error}${f.details?.length ? ` \u2014 ${f.details.join("; ")}` : ""}`,
-    path: f.filePath
-  }));
-  issues.push(
-    ...validateProviders(loaded, {
-      entitySurfaces: opts.entitySurfaces,
-      sourceRoot: opts.sourceRoot,
-      aliases: opts.aliases,
-      skipImportCheck: opts.skipImportCheck
-    })
-  );
-  if (issues.some((i) => i.severity === "error")) {
-    return { ...base, loadFailures: failures, issues };
-  }
-  const written = [];
-  for (const { definition, filePath } of loaded) {
-    const sourceYaml = relativeSource(filePath);
-    const content = generateProviderModule(definition, sourceYaml);
-    const outPath = join11(
-      opts.outputRoot,
-      definition.slug,
-      `${definition.slug}.provider.module.ts`
-    );
-    if (!opts.dryRun) {
-      writeIfChanged(outPath, content);
-    }
-    written.push(outPath);
-  }
-  return { ...base, written, loadFailures: failures, issues };
-}
-function writeIfChanged(outPath, content) {
-  if (existsSync9(outPath) && readFileSync7(outPath, "utf-8") === content) return;
-  mkdirSync2(dirname(outPath), { recursive: true });
-  writeFileSync2(outPath, content);
-}
-function relativeSource(filePath) {
-  const marker = "definitions/providers/";
-  const idx = filePath.lastIndexOf(marker);
-  if (idx !== -1) return filePath.slice(idx);
-  const slash = filePath.lastIndexOf("/");
-  return slash === -1 ? filePath : `definitions/providers/${filePath.slice(slash + 1)}`;
-}
+import { existsSync as existsSync10, mkdirSync as mkdirSync3, readFileSync as readFileSync8, statSync as statSync6, writeFileSync as writeFileSync3 } from "fs";
+import { dirname as dirname2, isAbsolute as isAbsolute2, join as join12, resolve as resolve6 } from "path";
 
 // src/cli/shared/adapter-emission-generator.ts
 import {
-  existsSync as existsSync10,
-  mkdirSync as mkdirSync3,
-  readFileSync as readFileSync8,
-  statSync as statSync6,
-  writeFileSync as writeFileSync3
+  existsSync as existsSync9,
+  mkdirSync as mkdirSync2,
+  readFileSync as readFileSync7,
+  statSync as statSync5,
+  writeFileSync as writeFileSync2
 } from "fs";
-import { dirname as dirname2, join as join12 } from "path";
+import { dirname, join as join11 } from "path";
 
 // src/cli/shared/sink-emission-generator.ts
 var SCAFFOLD_SENTINEL = "// <CODEGEN-SCAFFOLD-V1>";
@@ -8321,7 +8326,7 @@ function generateDefaultSink(input) {
 // for entities with external FK join-keys, fill the marked TODO(s) below.
 // Source: definitions entity '${input.entityName}' (surface: ${input.surface}).
 import { Injectable } from '@nestjs/common';
-import type { IIntegrationSink } from '@pattern-stack/codegen/subsystems';
+import type { IIntegrationSink } from '${subsystemsImport(input.mode ?? "package", "integration")}';
 import {
   ${n.repoClass},
   type ${n.projectionType},
@@ -8374,7 +8379,7 @@ function relationLabel(writeKey) {
 }
 
 // src/cli/shared/assembly-emission-generator.ts
-import { relative, resolve as resolve6, sep } from "path";
+import { relative, resolve as resolve5, sep } from "path";
 function generatedBanner(sourceDesc) {
   return `// @generated by @pattern-stack/codegen from ${sourceDesc} \u2014 DO NOT EDIT.
 // Hand edits are overwritten on re-emit. Regenerate with \`bun run codegen\`.`;
@@ -8412,7 +8417,7 @@ import {
   ExecuteIntegrationUseCase,
   INTEGRATION_CHANGE_SOURCE,
   INTEGRATION_SINK,
-} from '@pattern-stack/codegen/subsystems';
+} from '${subsystemsImport(input.mode ?? "package", "integration")}';
 import { ${adapterClass} } from '${adapterImport}';
 import { ${adapterModuleClass} } from '${adapterModuleImport}';
 import { ${sinkClass} } from '${sinkImport}';
@@ -8425,7 +8430,7 @@ import { ${token} } from '${tokensImport}';
  * inbound-integration assembly (RFC-0002 \xA72, Option A).
  *
  * Binds this module's INTEGRATION_CHANGE_SOURCE from the adapter's
- * \`changeSources['${input.entityName}']\` and INTEGRATION_SINK from
+ * \`changeSources.${input.entityName}\` and INTEGRATION_SINK from
  * ${sinkClass}, provides a local ExecuteIntegrationUseCase, and aliases+exports
  * it under ${token} (the bare class token is ambiguous at app root \u2014 every
  * assembly provides it). The substrate (cursor store, run recorder, differ,
@@ -8437,7 +8442,7 @@ import { ${token} } from '${tokensImport}';
   providers: [
     {
       provide: INTEGRATION_CHANGE_SOURCE,
-      useFactory: (adapter: ${adapterClass}) => adapter.changeSources['${input.entityName}'],
+      useFactory: (adapter: ${adapterClass}) => adapter.changeSources.${input.entityName},
       inject: [${adapterClass}],
     },
     {
@@ -8486,8 +8491,8 @@ function generateIntegrationAggregator(surface, entries) {
   );
   const importLines = sorted.map((e) => {
     const cls = assemblyModuleClass(e.entityName, e.provider);
-    const path34 = `./modules/${e.provider}/${e.entityName}-integration.module`;
-    return `import { ${cls} } from '${path34}';`;
+    const path36 = `./modules/${e.provider}/${e.entityName}-integration.module`;
+    return `import { ${cls} } from '${path36}';`;
   }).join("\n");
   const membersInline = moduleClasses.join(", ");
   return `${generatedBanner(`surface: ${surface}`)}
@@ -8539,17 +8544,17 @@ function resolveEntityModuleImports(input) {
   const repoClass = `${entityClass}Repository`;
   const moduleClass = `${pluralPascalCase(input.entityPlural)}Module`;
   const moduleGroupSegs = input.context ? ["modules", input.context, input.entityPlural] : ["modules", input.entityPlural];
-  const repoFileAbs = resolve6(
+  const repoFileAbs = resolve5(
     input.backendSrcAbs,
     ...moduleGroupSegs,
     `${input.entityName}.repository.ts`
   );
-  const moduleFileAbs = resolve6(
+  const moduleFileAbs = resolve5(
     input.backendSrcAbs,
     ...moduleGroupSegs,
     `${input.entityPlural}.module.ts`
   );
-  const assemblyDirAbs = resolve6(
+  const assemblyDirAbs = resolve5(
     input.backendSrcAbs,
     "integrations",
     input.surface,
@@ -8638,6 +8643,9 @@ var SURFACE_REGISTRY = {
     readPrimitive: true
   }
 };
+function isClientlessProvider(surfaces) {
+  return surfaces.length > 0 && surfaces.every((s) => SURFACE_REGISTRY[s]?.readPrimitive === true);
+}
 var SCAFFOLD_SENTINEL2 = "// <CODEGEN-SCAFFOLD-V1>";
 function generatedBanner2(sourceDesc) {
   return `// @generated by @pattern-stack/codegen from ${sourceDesc} \u2014 DO NOT EDIT.
@@ -8692,7 +8700,7 @@ function serializeFilterArray(filters) {
 ${items.join("\n")}
 ]`;
 }
-function buildReadPrimitiveEmission(providerSlug, providerPascal, surface, entities, entityDetection, clientExportName) {
+function buildReadPrimitiveEmission(providerSlug, providerPascal, surface, entities, entityDetection) {
   const canonicalTypes = [];
   const blocks = [];
   const entries = [];
@@ -8724,24 +8732,32 @@ export class ${className} extends IncrementalReadBase<${canonical}, ResolvedFilt
   // (e.g. Gmail \`q=\`); leave \`false\` to filter post-hydrate via \`matchesRecord\`.
   protected override readonly filterPushdown = false;${cursorOverride}
 
-  constructor(
-    private readonly auth: IAuthStrategy,
-    private readonly client: ${clientExportName},
-  ) {
+  constructor(private readonly auth: IAuthStrategy) {
     super();
   }
 
-  /** TODO: walk the vendor list endpoint \u2192 pages of \`Ref\` (id + cursor + meta). */
+  /**
+   * TODO: walk the vendor list endpoint \u2192 pages of \`Ref\` (id + cursor + meta).
+   * Per-connection (multi-account) adapters resolve credentials here from the
+   * threaded subscription, e.g.
+   * \`const client = <vendorClientFactory>({ accessToken: async () => (await this.auth.resolve(_ctx!.subscription!.externalRef)).accessToken });\`
+   * \u2014 there is no provider-level singleton client. Provider-level-auth adapters
+   * ignore \`_ctx\`.
+   */
   protected async *enumerate(
     _mode: ReadMode,
     _filter?: ResolvedFilter[],
     _pageSize?: number,
+    _ctx?: ReadContext,
   ): AsyncIterable<Ref[]> {
     throw new Error('not implemented: ${className}.enumerate');
   }
 
-  /** TODO: batched fetch-by-id \u2192 \`Map<id, raw>\` (\`mapConcurrent\`, or a vendor /batch). */
-  protected async hydrate(_ids: string[]): Promise<Map<string, unknown>> {
+  /**
+   * TODO: batched fetch-by-id \u2192 \`Map<id, raw>\` (\`mapConcurrent\`, or a vendor /batch).
+   * Use \`_ctx?.subscription?.id\` to key raw-landing rows per connection.
+   */
+  protected async hydrate(_ids: string[], _ctx?: ReadContext): Promise<Map<string, unknown>> {
     throw new Error('not implemented: ${className}.hydrate');
   }
 
@@ -8756,15 +8772,16 @@ export class ${className} extends IncrementalReadBase<${canonical}, ResolvedFilt
     return ${constName};
   }
 }`);
-    entries.push(`      ${entity}: new ${className}(this.auth, this.client),`);
+    entries.push(`      ${entity}: new ${className}(this.auth),`);
   }
   return { canonicalTypes, preamble: blocks.join("\n\n"), changeSourceEntries: entries };
 }
-function generateAdapterScaffold(def, surface, entities, entityDetection) {
+function generateAdapterScaffold(def, surface, entities, entityDetection, mode = "package") {
   const spec = SURFACE_REGISTRY[surface];
   if (!spec) throw new Error(`no surface package for '${surface}'`);
   const n = names(def.slug, surface);
   const client = parseImportRef(def.client.class);
+  const subsystemsSpec = subsystemsImport(mode, "integration");
   const entitiesLiteral = entities.length ? `[${entities.map((e) => `'${e}'`).join(", ")}]` : "[]";
   const readPrimitive = !!spec.readPrimitive && entities.length > 0;
   const rp = readPrimitive ? buildReadPrimitiveEmission(
@@ -8772,21 +8789,26 @@ function generateAdapterScaffold(def, surface, entities, entityDetection) {
     n.providerPascal,
     surface,
     entities,
-    entityDetection,
-    client.exportName
+    entityDetection
   ) : null;
   const surfaceTypeImports = [
     spec.portType,
     ...spec.l2Ports.map((p) => p.type),
     spec.capabilitiesType,
     ...rp ? rp.canonicalTypes : []
-  ].map((t) => `  ${t},`).join("\n");
-  const subsystemValueImport = rp ? `import { IncrementalReadBase } from '@pattern-stack/codegen/subsystems';
+  ].sort().map((t) => `  ${t},`).join("\n");
+  const subsystemValueImport = rp ? `import { IncrementalReadBase } from '${subsystemsSpec}';
 ` : "";
   const subsystemTypeImports = [
     "IAuthStrategy",
     "IChangeSource",
-    ...rp ? ["IntegrationSubscriptionView", "ReadMode", "Ref", "ResolvedFilter"] : []
+    ...rp ? [
+      "IntegrationSubscriptionView",
+      "ReadContext",
+      "ReadMode",
+      "Ref",
+      "ResolvedFilter"
+    ] : []
   ].map((t) => `  ${t},`).join("\n");
   const changeSourcesAssign = rp ? `
     this.changeSources = {
@@ -8826,6 +8848,14 @@ ${rp.preamble}
   const l2Section = l2Members ? `
 ${l2Members}
 ` : "";
+  const clientTypeImport = rp ? "" : `import type { ${client.exportName} } from '${client.path}';
+`;
+  const providerTokenImport = rp ? `import { ${n.strategyToken} } from '../../../providers/${def.slug}/${def.slug}.provider.module';` : `import { ${n.strategyToken}, ${n.clientToken} } from '../../../providers/${def.slug}/${def.slug}.provider.module';`;
+  const ctorClientParam = rp ? "" : `
+    @Inject(${n.clientToken}) private readonly client: ${client.exportName},`;
+  const ctorOpen = rp ? `  constructor(@Inject(${n.strategyToken}) readonly auth: IAuthStrategy) {${changeSourcesAssign}}` : `  constructor(
+    @Inject(${n.strategyToken}) readonly auth: IAuthStrategy,${ctorClientParam}
+  ) {${changeSourcesAssign}}`;
   return `${SCAFFOLD_SENTINEL2}
 // Scaffolded once by @pattern-stack/codegen, then author-owned. Re-running
 // codegen detects the sentinel above and SKIPS this file \u2014 your edits are safe.
@@ -8837,9 +8867,8 @@ ${surfaceTypeImports}
 import { ${spec.noCapsConst} } from '${spec.packageName}';
 ${subsystemValueImport}import type {
 ${subsystemTypeImports}
-} from '@pattern-stack/codegen/subsystems';
-import type { ${client.exportName} } from '${client.path}';
-import { ${n.strategyToken}, ${n.clientToken} } from '../../../providers/${def.slug}/${def.slug}.provider.module';
+} from '${subsystemsSpec}';
+${clientTypeImport}${providerTokenImport}
 ${preambleSection}
 @Injectable()
 export class ${n.adapterClass} implements ${spec.portType} {
@@ -8848,10 +8877,7 @@ export class ${n.adapterClass} implements ${spec.portType} {
 ${capabilityBody}
   };
 
-  constructor(
-    @Inject(${n.strategyToken}) readonly auth: IAuthStrategy,
-    @Inject(${n.clientToken}) private readonly client: ${client.exportName},
-  ) {${changeSourcesAssign}}
+${ctorOpen}
 ${l2Section}
 ${changeSourcesDecl}
 
@@ -8883,10 +8909,10 @@ function generateAdaptersBarrel(surface, providerSlugs) {
 ${lines}
 `;
 }
-function generateSurfaceTokens(surface) {
+function generateSurfaceTokens(surface, mode = "package") {
   const n = names("__placeholder__", surface);
   return `${generatedBanner2(`surface: ${surface}`)}
-import type { IChangeSource } from '@pattern-stack/codegen/subsystems';
+import type { IChangeSource } from '${subsystemsImport(mode, "integration")}';
 
 /** The assembled list of every ${surface} adapter's contribution. */
 export const ${n.contributionsToken} = Symbol.for('@app/integrations/${surface}.adapter-contributions');
@@ -8903,7 +8929,7 @@ export interface AdapterContribution {
 }
 `;
 }
-function generateSurfaceAggregator(surface, providerSlugs) {
+function generateSurfaceAggregator(surface, providerSlugs, mode = "package") {
   const n = names("__placeholder__", surface);
   const slugs = [...providerSlugs].sort();
   const per = slugs.map((slug) => names(slug, surface));
@@ -8930,7 +8956,7 @@ import {
   MemoryEntityChangeSourceRegistry,
   type IChangeSource,
   type IEntityChangeSourceRegistry,
-} from '@pattern-stack/codegen/subsystems';
+} from '${subsystemsImport(mode, "integration")}';
 ${moduleImport}
 ${adapterImports}
 import {
@@ -9019,6 +9045,7 @@ function jsKey(key) {
   return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(key) ? key : `'${key}'`;
 }
 function emitAdapters(opts) {
+  const mode = opts.mode ?? "package";
   const result = {
     written: [],
     scaffoldsWritten: [],
@@ -9049,14 +9076,14 @@ function emitAdapters(opts) {
   }
   const defBySlug = new Map(opts.providers.map((p) => [p.definition.slug, p.definition]));
   for (const [surface, slugs] of bySurface) {
-    const surfaceDir = join12(opts.outputRoot, surface);
-    const adaptersDir = join12(surfaceDir, "adapters");
+    const surfaceDir = join11(opts.outputRoot, surface);
+    const adaptersDir = join11(surfaceDir, "adapters");
     for (const slug of slugs) {
       const def = defBySlug.get(slug);
-      const providerDir = join12(adaptersDir, slug);
-      const scaffoldPath = join12(providerDir, `${slug}-${surface}.adapter.ts`);
-      const modulePath = join12(providerDir, `${slug}-${surface}.adapter.module.ts`);
-      if (existsSync10(scaffoldPath)) {
+      const providerDir = join11(adaptersDir, slug);
+      const scaffoldPath = join11(providerDir, `${slug}-${surface}.adapter.ts`);
+      const modulePath = join11(providerDir, `${slug}-${surface}.adapter.module.ts`);
+      if (existsSync9(scaffoldPath)) {
         result.scaffoldsSkipped.push(scaffoldPath);
       } else {
         const surfaceEntityNames = entitiesBySurface.get(surface) ?? [];
@@ -9069,36 +9096,37 @@ function emitAdapters(opts) {
           def,
           surface,
           surfaceEntityNames,
-          entityDetection
+          entityDetection,
+          mode
         );
         if (!opts.dryRun) writeFile(scaffoldPath, content);
         result.scaffoldsWritten.push(scaffoldPath);
       }
       const moduleContent = generateAdapterModule(def, surface);
-      if (!opts.dryRun) writeIfChanged2(modulePath, moduleContent);
+      if (!opts.dryRun) writeIfChanged(modulePath, moduleContent);
       result.written.push(modulePath);
     }
-    const barrelPath = join12(adaptersDir, "index.ts");
-    const tokensPath = join12(surfaceDir, `${surface}-adapters.tokens.ts`);
-    const aggregatorPath = join12(surfaceDir, `${surface}-adapters.module.ts`);
-    const typedViewPath = join12(surfaceDir, "types.generated.ts");
+    const barrelPath = join11(adaptersDir, "index.ts");
+    const tokensPath = join11(surfaceDir, `${surface}-adapters.tokens.ts`);
+    const aggregatorPath = join11(surfaceDir, `${surface}-adapters.module.ts`);
+    const typedViewPath = join11(surfaceDir, "types.generated.ts");
     const files = [
       [barrelPath, generateAdaptersBarrel(surface, slugs)],
-      [tokensPath, generateSurfaceTokens(surface)],
-      [aggregatorPath, generateSurfaceAggregator(surface, slugs)],
+      [tokensPath, generateSurfaceTokens(surface, mode)],
+      [aggregatorPath, generateSurfaceAggregator(surface, slugs, mode)],
       [typedViewPath, generateTypedView(surface, slugs, entitiesBySurface.get(surface) ?? [])]
     ];
-    for (const [path34, content] of files) {
-      if (!opts.dryRun) writeIfChanged2(path34, content);
-      result.written.push(path34);
+    for (const [path36, content] of files) {
+      if (!opts.dryRun) writeIfChanged(path36, content);
+      result.written.push(path36);
     }
     if (opts.backendSrcAbs) {
       const aliases = opts.aliases ?? {};
       const surfaceEntities = entitiesBySurface.get(surface) ?? [];
       const tokenEntries = [];
       const assemblyEntries = [];
-      const sinksDir = join12(surfaceDir, "sinks");
-      const modulesDir = join12(surfaceDir, "modules");
+      const sinksDir = join11(surfaceDir, "sinks");
+      const modulesDir = join11(surfaceDir, "modules");
       for (const entityName of surfaceEntities) {
         const def = entityByName.get(entityName);
         const pattern = def?.entity.pattern ?? (Array.isArray(def?.entity.patterns) ? def?.entity.patterns?.[0] : void 0);
@@ -9123,17 +9151,17 @@ function emitAdapters(opts) {
           backendSrcAbs: opts.backendSrcAbs,
           aliases
         });
-        const sinkPath = join12(sinksDir, `${entityName}.sink.ts`);
-        if (existsSync10(sinkPath)) {
+        const sinkPath = join11(sinksDir, `${entityName}.sink.ts`);
+        if (existsSync9(sinkPath)) {
           result.scaffoldsSkipped.push(sinkPath);
         } else {
           const sinkInput = buildSinkInput(def, surface, slugs[0], loc.repoImportSpecifier);
-          const sinkContent = generateDefaultSink(sinkInput);
+          const sinkContent = generateDefaultSink({ ...sinkInput, mode });
           if (!opts.dryRun) writeFile(sinkPath, sinkContent);
           result.scaffoldsWritten.push(sinkPath);
         }
         for (const slug of slugs) {
-          const assemblyPath = join12(
+          const assemblyPath = join11(
             modulesDir,
             slug,
             `${entityName}-integration.module.ts`
@@ -9147,23 +9175,24 @@ function emitAdapters(opts) {
             moduleClass: loc.moduleClass,
             repoImportSpecifier: loc.repoImportSpecifier,
             repoClass: loc.repoClass,
-            sourceDesc: `definitions/providers/${slug}.yaml`
+            sourceDesc: `definitions/providers/${slug}.yaml`,
+            mode
           });
-          if (!opts.dryRun) writeIfChanged2(assemblyPath, assemblyContent);
+          if (!opts.dryRun) writeIfChanged(assemblyPath, assemblyContent);
           result.assembliesWritten.push(assemblyPath);
           tokenEntries.push({ entityName, entityClass: loc.entityClass, provider: slug });
           assemblyEntries.push({ entityName, provider: slug });
         }
       }
-      const integrationTokensPath = join12(
+      const integrationTokensPath = join11(
         surfaceDir,
         `${surface}-integration.tokens.ts`
       );
       const tokensContent = generateIntegrationTokens(surface, tokenEntries);
-      if (!opts.dryRun) writeIfChanged2(integrationTokensPath, tokensContent);
+      if (!opts.dryRun) writeIfChanged(integrationTokensPath, tokensContent);
       result.tokensWritten.push(integrationTokensPath);
       if (assemblyEntries.length > 0) {
-        const integrationAggregatorPath = join12(
+        const integrationAggregatorPath = join11(
           surfaceDir,
           `${surface}-integration.module.ts`
         );
@@ -9171,7 +9200,7 @@ function emitAdapters(opts) {
           surface,
           assemblyEntries
         );
-        if (!opts.dryRun) writeIfChanged2(integrationAggregatorPath, aggregatorContent);
+        if (!opts.dryRun) writeIfChanged(integrationAggregatorPath, aggregatorContent);
         result.integrationAggregatorsWritten.push(integrationAggregatorPath);
       }
     }
@@ -9228,44 +9257,240 @@ function pascalFromSnake(s) {
   return camel.charAt(0).toUpperCase() + camel.slice(1);
 }
 function writeFile(outPath, content) {
-  mkdirSync3(dirname2(outPath), { recursive: true });
-  writeFileSync3(outPath, content);
+  mkdirSync2(dirname(outPath), { recursive: true });
+  writeFileSync2(outPath, content);
 }
-function writeIfChanged2(outPath, content) {
-  if (existsSync10(outPath) && statSync6(outPath).isFile() && readFileSync8(outPath, "utf-8") === content) {
+function writeIfChanged(outPath, content) {
+  if (existsSync9(outPath) && statSync5(outPath).isFile() && readFileSync7(outPath, "utf-8") === content) {
     return;
   }
   writeFile(outPath, content);
 }
 
-// src/cli/shared/events-path.ts
-import path12 from "path";
-var FALLBACK = "events";
-function resolveEventsDirFromConfig(cwd, config) {
-  const configured = config?.paths?.events_dir;
-  if (typeof configured === "string" && configured.length > 0) {
-    return path12.resolve(cwd, configured);
-  }
-  return path12.resolve(cwd, FALLBACK);
-}
-function resolveEventsDir(ctx) {
-  return resolveEventsDirFromConfig(ctx.cwd, ctx.config);
-}
-
-// src/cli/ui/output.ts
-var MAX_ERROR_LEN = 500;
-function printSuccess(msg) {
-  if (isJsonMode()) return;
-  console.log(`${theme.success(icons.success)} ${msg}`);
+// src/cli/shared/provider-module-generator.ts
+function providerPascalCase(slug) {
+  return slug.split("-").filter(Boolean).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
 }
-function printError(msg) {
-  if (isJsonMode()) return;
-  const truncated = msg.length > MAX_ERROR_LEN ? msg.slice(0, MAX_ERROR_LEN) + "\u2026" : msg;
-  console.error(`${theme.error(icons.error)} ${truncated}`);
+function providerConstantCase(slug) {
+  return slug.replace(/-/g, "_").toUpperCase();
 }
-function printWarning(msg) {
-  if (isJsonMode()) return;
-  console.warn(`${theme.warning(icons.warning)} ${msg}`);
+function providerModuleBanner(sourceYaml) {
+  return `// @generated by @pattern-stack/codegen from ${sourceYaml} \u2014 DO NOT EDIT.
+// Hand edits are overwritten on re-emit. Regenerate with \`bun run codegen\`. To change this provider, edit its \`definitions/providers/*.yaml\`.`;
+}
+function generateProviderModule(def, sourceYaml, mode = "package") {
+  const { slug } = def;
+  const Pascal = providerPascalCase(slug);
+  const CONST = providerConstantCase(slug);
+  const strategy = parseImportRef(def.auth.strategy);
+  const client = parseImportRef(def.client.class);
+  const strategyToken = `${CONST}_AUTH_STRATEGY`;
+  const clientToken = `${CONST}_CLIENT`;
+  const surfaces = def.surfaces.join(", ");
+  const title = def.display_name ? `${def.display_name} (\`${slug}\`)` : `\`${slug}\``;
+  if (isClientlessProvider(def.surfaces)) {
+    return `${providerModuleBanner(sourceYaml)}
+/**
+ * Provider module for ${title}.
+ *
+ * Surfaces: ${surfaces}.
+ *
+ * Per-connection (read-primitive) provider \u2014 exposes \`${strategyToken}\`, the
+ * per-connection credential resolver the interaction adapters use (RFC-0003 R5:
+ * \`auth.resolve(ctx.subscription.externalRef)\`). There is NO provider-level
+ * singleton client; adapters build a per-connection client inside their
+ * \`enumerate\`/\`hydrate\`. \`${strategyToken}\` resolves the already-built
+ * \`${slug}\` strategy from the @Global \`STRATEGY_REGISTRY\` (wired by the
+ * consumer's AuthBindings module) \u2014 the strategy may need DI deps a bare class
+ * can't satisfy, so it is registry-resolved, not provided directly.
+ */
+import { Module } from '@nestjs/common';
+import {
+  type ProviderStrategyRegistry,
+  STRATEGY_REGISTRY,
+} from '${subsystemsImport(mode, "auth")}';
+
+/** DI token for the \`${slug}\` provider's auth strategy (resolved from STRATEGY_REGISTRY). */
+export const ${strategyToken} = Symbol('${strategyToken}');
+
+const PROVIDER_SLUG = '${slug}';
+
+@Module({
+  providers: [
+    {
+      provide: ${strategyToken},
+      useFactory: (registry: ProviderStrategyRegistry) => {
+        const strategy = registry.get(PROVIDER_SLUG);
+        if (!strategy) {
+          throw new Error(
+            \`${Pascal}ProviderModule: no '\${PROVIDER_SLUG}' strategy registered in STRATEGY_REGISTRY (wire it in your consumer AuthBindings module)\`,
+          );
+        }
+        return strategy;
+      },
+      inject: [STRATEGY_REGISTRY],
+    },
+  ],
+  exports: [${strategyToken}],
+})
+export class ${Pascal}ProviderModule {}
+`;
+  }
+  return `${providerModuleBanner(sourceYaml)}
+/**
+ * Provider module for ${title}.
+ *
+ * Surfaces: ${surfaces}.
+ *
+ * Wires the declared auth strategy and API client under the provider-specific
+ * DI tokens \`${strategyToken}\` and \`${clientToken}\`. Per the auth subsystem
+ * contract, strategies are registered under provider-specific tokens rather
+ * than a single \`AUTH_STRATEGY\`. Registry aggregation (RFC-0001 \xA73) is
+ * emitted by a later codegen step.
+ */
+import { Module } from '@nestjs/common';
+import { ${strategy.exportName} } from '${strategy.path}';
+import { ${client.exportName} } from '${client.path}';
+
+/** DI token for the \`${slug}\` provider's auth strategy. */
+export const ${strategyToken} = Symbol('${strategyToken}');
+/** DI token for the \`${slug}\` provider's API client. */
+export const ${clientToken} = Symbol('${clientToken}');
+
+@Module({
+  providers: [
+    ${strategy.exportName},
+    ${client.exportName},
+    { provide: ${strategyToken}, useExisting: ${strategy.exportName} },
+    { provide: ${clientToken}, useExisting: ${client.exportName} },
+  ],
+  exports: [
+    ${strategy.exportName},
+    ${client.exportName},
+    ${strategyToken},
+    ${clientToken},
+  ],
+})
+export class ${Pascal}ProviderModule {}
+`;
+}
+function resolveTsconfigAliases(consumerRoot) {
+  const tsconfigPath = join12(consumerRoot, "tsconfig.json");
+  if (!existsSync10(tsconfigPath)) return null;
+  let parsed;
+  try {
+    parsed = JSON.parse(stripJsonComments(readFileSync8(tsconfigPath, "utf-8")));
+  } catch {
+    return null;
+  }
+  const compilerOptions = parsed.compilerOptions ?? {};
+  const baseUrl = compilerOptions.baseUrl ?? ".";
+  const sourceRoot = isAbsolute2(baseUrl) ? baseUrl : resolve6(consumerRoot, baseUrl);
+  const aliases = {};
+  for (const [pattern, targets] of Object.entries(compilerOptions.paths ?? {})) {
+    if (!Array.isArray(targets) || targets.length === 0) continue;
+    const aliasKey = pattern.replace(/\/\*$/, "");
+    const target = targets[0].replace(/\/\*$/, "");
+    aliases[aliasKey] = isAbsolute2(target) ? target : resolve6(sourceRoot, target);
+  }
+  return { sourceRoot, aliases };
+}
+function stripJsonComments(input) {
+  return input.replace(/\/\*[\s\S]*?\*\//g, "").replace(/(^|[^:])\/\/.*$/gm, "$1");
+}
+function generateProviderModules(opts) {
+  const base = {
+    providersDir: opts.providersDir,
+    skipped: false,
+    written: [],
+    loadFailures: [],
+    issues: []
+  };
+  if (!existsSync10(opts.providersDir) || !statSync6(opts.providersDir).isDirectory()) {
+    return { ...base, skipped: true };
+  }
+  const files = findYamlFiles(opts.providersDir);
+  if (files.length === 0) return { ...base, skipped: true };
+  const { successes, failures } = loadProvidersFromYaml(files);
+  const loaded = successes.map((s) => ({
+    definition: s.definition,
+    filePath: s.filePath
+  }));
+  const issues = failures.map((f) => ({
+    severity: "error",
+    type: "provider_load_failed",
+    message: `${f.error}${f.details?.length ? ` \u2014 ${f.details.join("; ")}` : ""}`,
+    path: f.filePath
+  }));
+  issues.push(
+    ...validateProviders(loaded, {
+      entitySurfaces: opts.entitySurfaces,
+      sourceRoot: opts.sourceRoot,
+      aliases: opts.aliases,
+      skipImportCheck: opts.skipImportCheck
+    })
+  );
+  if (issues.some((i) => i.severity === "error")) {
+    return { ...base, loadFailures: failures, issues };
+  }
+  const mode = opts.mode ?? "package";
+  const written = [];
+  for (const { definition, filePath } of loaded) {
+    const sourceYaml = relativeSource(filePath);
+    const content = generateProviderModule(definition, sourceYaml, mode);
+    const outPath = join12(
+      opts.outputRoot,
+      definition.slug,
+      `${definition.slug}.provider.module.ts`
+    );
+    if (!opts.dryRun) {
+      writeIfChanged2(outPath, content);
+    }
+    written.push(outPath);
+  }
+  return { ...base, written, loadFailures: failures, issues };
+}
+function writeIfChanged2(outPath, content) {
+  if (existsSync10(outPath) && readFileSync8(outPath, "utf-8") === content) return;
+  mkdirSync3(dirname2(outPath), { recursive: true });
+  writeFileSync3(outPath, content);
+}
+function relativeSource(filePath) {
+  const marker = "definitions/providers/";
+  const idx = filePath.lastIndexOf(marker);
+  if (idx !== -1) return filePath.slice(idx);
+  const slash = filePath.lastIndexOf("/");
+  return slash === -1 ? filePath : `definitions/providers/${filePath.slice(slash + 1)}`;
+}
+
+// src/cli/shared/events-path.ts
+import path13 from "path";
+var FALLBACK = "events";
+function resolveEventsDirFromConfig(cwd, config) {
+  const configured = config?.paths?.events_dir;
+  if (typeof configured === "string" && configured.length > 0) {
+    return path13.resolve(cwd, configured);
+  }
+  return path13.resolve(cwd, FALLBACK);
+}
+function resolveEventsDir(ctx) {
+  return resolveEventsDirFromConfig(ctx.cwd, ctx.config);
+}
+
+// src/cli/ui/output.ts
+var MAX_ERROR_LEN = 500;
+function printSuccess(msg) {
+  if (isJsonMode()) return;
+  console.log(`${theme.success(icons.success)} ${msg}`);
+}
+function printError(msg) {
+  if (isJsonMode()) return;
+  const truncated = msg.length > MAX_ERROR_LEN ? msg.slice(0, MAX_ERROR_LEN) + "\u2026" : msg;
+  console.error(`${theme.error(icons.error)} ${truncated}`);
+}
+function printWarning(msg) {
+  if (isJsonMode()) return;
+  console.warn(`${theme.warning(icons.warning)} ${msg}`);
 }
 function printInfo(msg) {
   if (isJsonMode()) return;
@@ -9275,10 +9500,10 @@ function printInfo(msg) {
 // src/cli/commands/entity.ts
 function resolveProvidersDir(ctx) {
   const fromConfig = ctx.config?.paths?.providers;
-  return fromConfig != null ? path13.resolve(ctx.cwd, fromConfig) : path13.resolve(ctx.cwd, "definitions/providers");
+  return fromConfig != null ? path14.resolve(ctx.cwd, fromConfig) : path14.resolve(ctx.cwd, "definitions/providers");
 }
 function listEntityYamls2(dir, providersDir) {
-  if (!fs9.existsSync(dir)) return [];
+  if (!fs10.existsSync(dir)) return [];
   return findYamlFiles(dir, {
     excludeDirs: providersDir ? [providersDir] : []
   });
@@ -9357,11 +9582,11 @@ async function hints(ctx) {
     { command: "codegen entity validate", description: "Validate YAML definitions" },
     { command: "codegen entity list", description: "List entities as a table" }
   ];
-  const providersDir = ctx.config?.paths?.providers != null ? path13.resolve(
+  const providersDir = ctx.config?.paths?.providers != null ? path14.resolve(
     ctx.cwd,
     ctx.config.paths.providers
-  ) : path13.resolve(ctx.cwd, "definitions/providers");
-  if (fs9.existsSync(providersDir)) {
+  ) : path14.resolve(ctx.cwd, "definitions/providers");
+  if (fs10.existsSync(providersDir)) {
     baseHints.push({
       command: "codegen entity new --all",
       description: "Regenerate provider modules + adapter scaffolds (Track D)"
@@ -9416,14 +9641,14 @@ var EntityNewCommand = class extends Command2 {
     }
     let targets = [];
     if (this.all) {
-      const dir = ctx.entitiesDir ?? path13.resolve(ctx.cwd, "entities");
+      const dir = ctx.entitiesDir ?? path14.resolve(ctx.cwd, "entities");
       targets = listEntityYamls2(dir, resolveProvidersDir(ctx));
       if (targets.length === 0) {
         printError(`No entity YAML files found in ${dir}`);
         return 1;
       }
     } else if (this.yaml) {
-      targets = [path13.resolve(ctx.cwd, this.yaml)];
+      targets = [path14.resolve(ctx.cwd, this.yaml)];
     } else {
       printError("Missing YAML path. Pass a file or --all.");
       return 2;
@@ -9440,7 +9665,7 @@ var EntityNewCommand = class extends Command2 {
     }
     if (invalid.length > 0 && !this.continueOnError) {
       for (const i of invalid) {
-        printError(`${path13.basename(i.file)} \u2014 ${i.message}`);
+        printError(`${path14.basename(i.file)} \u2014 ${i.message}`);
         for (const detail of i.details ?? []) {
           printError(`   \u2022 ${detail}`);
         }
@@ -9449,7 +9674,7 @@ var EntityNewCommand = class extends Command2 {
         return 1;
       }
     }
-    const entitiesDirForEmits = ctx.entitiesDir ?? path13.resolve(ctx.cwd, "entities");
+    const entitiesDirForEmits = ctx.entitiesDir ?? path14.resolve(ctx.cwd, "entities");
     const eventsDirForEmits = resolveEventsDir(ctx);
     const allEntitiesForEmits = loadEntities(entitiesDirForEmits, {
       excludeDirs: [resolveProvidersDir(ctx)]
@@ -9498,34 +9723,35 @@ var EntityNewCommand = class extends Command2 {
         if (!isJsonMode()) return 1;
       }
     }
-    const entitiesDir = ctx.entitiesDir ?? path13.resolve(ctx.cwd, "entities");
-    const relationshipsDir = path13.resolve(ctx.cwd, "relationships");
+    const entitiesDir = ctx.entitiesDir ?? path14.resolve(ctx.cwd, "entities");
+    const relationshipsDir = path14.resolve(ctx.cwd, "relationships");
     const generatedDir = resolveGeneratedDir(ctx);
     const architecture = resolveArchitecture(ctx);
     const subsystemsRoot = resolveSubsystemsRoot(ctx);
-    const scopeEntityTypePath = path13.resolve(
+    const scopeEntityTypePath = path14.resolve(
       subsystemsRoot,
       "jobs/generated/scope-entity-type.ts"
     );
     const eventsDir = resolveEventsDir(ctx);
-    const eventCodegenOutputDir = path13.resolve(
+    const eventCodegenOutputDir = path14.resolve(
       subsystemsRoot,
       "events/generated"
     );
-    const bridgeRegistryOutputDir = path13.resolve(
+    const bridgeRegistryOutputDir = path14.resolve(
       subsystemsRoot,
       "bridge/generated"
     );
     const backendSrcForHandlers = ctx.config?.paths?.backend_src ?? "src";
-    const bridgeHandlersDir = path13.resolve(
+    const runtimeMode = resolveRuntimeMode(ctx.config);
+    const bridgeHandlersDir = path14.resolve(
       ctx.cwd,
       backendSrcForHandlers,
       "jobs"
     );
     const orchestrationConfigured = ctx.config?.paths?.orchestration_src;
-    const orchestrationOutputRoot = path13.resolve(
+    const orchestrationOutputRoot = path14.resolve(
       ctx.cwd,
-      typeof orchestrationConfigured === "string" && orchestrationConfigured.length > 0 ? orchestrationConfigured : path13.join(backendSrcForHandlers, "orchestration")
+      typeof orchestrationConfigured === "string" && orchestrationConfigured.length > 0 ? orchestrationConfigured : path14.join(backendSrcForHandlers, "orchestration")
     );
     const orchestrationGlobs = (() => {
       const fromCfg = ctx.config?.patterns;
@@ -9653,7 +9879,7 @@ var EntityNewCommand = class extends Command2 {
         }
         if (invalid.length > 0) {
           for (const i of invalid) {
-            printWarning(`${path13.basename(i.file)} \u2014 ${i.message}`);
+            printWarning(`${path14.basename(i.file)} \u2014 ${i.message}`);
           }
         }
         console.log("");
@@ -9671,7 +9897,7 @@ var EntityNewCommand = class extends Command2 {
     }
     const succeeded = [];
     const failed = [
-      ...invalid.map((i) => ({ name: path13.basename(i.file), file: i.file, message: i.message }))
+      ...invalid.map((i) => ({ name: path14.basename(i.file), file: i.file, message: i.message }))
     ];
     for (const v of validated) {
       if (!isJsonMode()) {
@@ -9714,6 +9940,14 @@ var EntityNewCommand = class extends Command2 {
         printWarning(`subsystem barrel regeneration failed \u2014 ${msg}`);
       }
     }
+    try {
+      await regenerateSubsystemSchemaBarrel({ ctx, generatedDir });
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      if (!isJsonMode()) {
+        printWarning(`subsystem schema barrel regeneration failed \u2014 ${msg}`);
+      }
+    }
     let scopeResult = null;
     try {
       scopeResult = await generateScopeEntityType({
@@ -9786,12 +10020,12 @@ var EntityNewCommand = class extends Command2 {
     let providerResult = null;
     try {
       const providersDir = resolveProvidersDir(ctx);
-      const providerOutputRoot = path13.resolve(
+      const providerOutputRoot = path14.resolve(
         ctx.cwd,
         backendSrcForHandlers,
         "integrations/providers"
       );
-      const entitySurfaces = fs9.existsSync(entitiesDir) ? collectEntitySurfaces(
+      const entitySurfaces = fs10.existsSync(entitiesDir) ? collectEntitySurfaces(
         loadEntitiesFromYaml(
           findYamlFiles(entitiesDir, { excludeDirs: [providersDir] })
         ).successes.map((s) => s.definition)
@@ -9803,7 +10037,8 @@ var EntityNewCommand = class extends Command2 {
         entitySurfaces,
         sourceRoot: tsAliases?.sourceRoot,
         aliases: tsAliases?.aliases,
-        skipImportCheck: tsAliases === null
+        skipImportCheck: tsAliases === null,
+        mode: runtimeMode
       });
       if (!providerResult.skipped && !isJsonMode()) {
         for (const issue of providerResult.issues) {
@@ -9827,12 +10062,12 @@ var EntityNewCommand = class extends Command2 {
     try {
       if (providerResult && !providerResult.skipped && providerResult.issues.length === 0) {
         const providersDir = providerResult.providersDir;
-        const adapterOutputRoot = path13.resolve(
+        const adapterOutputRoot = path14.resolve(
           ctx.cwd,
           backendSrcForHandlers,
           "integrations"
         );
-        const entityDefs = fs9.existsSync(entitiesDir) ? loadEntitiesFromYaml(
+        const entityDefs = fs10.existsSync(entitiesDir) ? loadEntitiesFromYaml(
           findYamlFiles(entitiesDir, { excludeDirs: [providersDir] })
         ).successes.map((s) => s.definition) : [];
         const loadedProviders = loadProvidersFromYaml(
@@ -9846,8 +10081,9 @@ var EntityNewCommand = class extends Command2 {
           providers: loadedProviders,
           entities: entityDefs,
           outputRoot: adapterOutputRoot,
-          backendSrcAbs: path13.resolve(ctx.cwd, backendSrcForHandlers),
-          aliases: assemblyTsAliases?.aliases ?? {}
+          backendSrcAbs: path14.resolve(ctx.cwd, backendSrcForHandlers),
+          aliases: assemblyTsAliases?.aliases ?? {},
+          mode: runtimeMode
         });
         if (!isJsonMode()) {
           if (adapterResult.written.length || adapterResult.scaffoldsWritten.length) {
@@ -9947,22 +10183,22 @@ var EntityNewCommand = class extends Command2 {
       }
       if (barrelResult) {
         printInfo(
-          `barrels regenerated (${barrelResult.entityCount} entities) \u2192 ${path13.relative(ctx.cwd, barrelResult.modulesBarrel)}, ${path13.relative(ctx.cwd, barrelResult.schemaBarrel)}`
+          `barrels regenerated (${barrelResult.entityCount} entities) \u2192 ${path14.relative(ctx.cwd, barrelResult.modulesBarrel)}, ${path14.relative(ctx.cwd, barrelResult.schemaBarrel)}`
         );
       }
       if (scopeResult) {
         printInfo(
-          `scope-entity-type regenerated (${scopeResult.scopeableNames.length} scopeable) \u2192 ${path13.relative(ctx.cwd, scopeResult.outputPath)}`
+          `scope-entity-type regenerated (${scopeResult.scopeableNames.length} scopeable) \u2192 ${path14.relative(ctx.cwd, scopeResult.outputPath)}`
         );
       }
       if (eventCodegenResult) {
         printInfo(
-          `event codegen regenerated (${eventCodegenResult.eventCount} events) \u2192 ${path13.relative(ctx.cwd, eventCodegenResult.outputDir)}`
+          `event codegen regenerated (${eventCodegenResult.eventCount} events) \u2192 ${path14.relative(ctx.cwd, eventCodegenResult.outputDir)}`
         );
       }
       if (orchestrationResult && orchestrationResult.patterns.length > 0) {
         printInfo(
-          `orchestration regenerated (${orchestrationResult.patterns.length} patterns, ${orchestrationResult.files.length} files) \u2192 ${path13.relative(ctx.cwd, orchestrationResult.outputRoot)}`
+          `orchestration regenerated (${orchestrationResult.patterns.length} patterns, ${orchestrationResult.files.length} files) \u2192 ${path14.relative(ctx.cwd, orchestrationResult.outputRoot)}`
         );
       }
     }
@@ -10048,8 +10284,8 @@ var EntityValidateCommand = class extends Command2 {
       json: this.json,
       skipDetection: true
     });
-    const targetDir = this.dir ? path13.resolve(ctx.cwd, this.dir) : ctx.entitiesDir ?? path13.resolve(ctx.cwd, "entities");
-    if (!fs9.existsSync(targetDir)) {
+    const targetDir = this.dir ? path14.resolve(ctx.cwd, this.dir) : ctx.entitiesDir ?? path14.resolve(ctx.cwd, "entities");
+    if (!fs10.existsSync(targetDir)) {
       printError(`Directory not found: ${targetDir}`);
       return 1;
     }
@@ -10100,8 +10336,8 @@ var entityNoun = {
 var entity_default = entityNoun;
 
 // src/cli/commands/subsystem.ts
-import fs11 from "fs";
-import path22 from "path";
+import fs13 from "fs";
+import path24 from "path";
 import { Command as Command3, Option as Option3 } from "clipanion";
 
 // src/cli/shared/config-block-detect.ts
@@ -10134,26 +10370,26 @@ function stripConfigBlock(yamlSource, subsystem) {
 }
 
 // src/cli/shared/events-scaffold-locals.ts
-import path14 from "path";
+import path15 from "path";
 function resolveEventsScaffoldLocals(input) {
   const { cwd, config } = input;
   void input.fileExists;
   const eventsBlock = config?.events ?? {};
   const subsystemsRoot = resolveSubsystemsRootFromConfig(cwd, config);
-  const configPath = path14.resolve(cwd, "codegen.config.yaml");
-  const schemaPath = path14.resolve(
+  const configPath = path15.resolve(cwd, "codegen.config.yaml");
+  const schemaPath = path15.resolve(
     subsystemsRoot,
     "events",
     "domain-events.schema.ts"
   );
-  const generatedKeepPath = path14.resolve(
+  const generatedKeepPath = path15.resolve(
     subsystemsRoot,
     "events",
     "generated",
     ".gitkeep"
   );
   return {
-    appName: path14.basename(cwd),
+    appName: path15.basename(cwd),
     multiTenant: normaliseMultiTenant(eventsBlock.multi_tenant),
     configPath,
     schemaPath,
@@ -10179,7 +10415,7 @@ function localsToHygenArgs(locals) {
 }
 
 // src/cli/shared/jobs-scaffold-locals.ts
-import path15 from "path";
+import path16 from "path";
 var MAIN_HOOK_SENTINEL = "JOBS \u2014 Embedded worker mode (optional)";
 function workerSkipValue(exists) {
   return exists ? "true" : "";
@@ -10188,10 +10424,10 @@ function resolveJobsScaffoldLocals(input) {
   const { cwd, config, fileExists, readFile } = input;
   const jobsBlock = config?.jobs ?? {};
   const subsystemsRoot = resolveSubsystemsRootFromConfig(cwd, config);
-  const workerPath = path15.resolve(cwd, "worker.ts");
-  const mainTsPath = path15.resolve(cwd, "src/main.ts");
-  const configPath = path15.resolve(cwd, "codegen.config.yaml");
-  const schemaPath = path15.resolve(
+  const workerPath = path16.resolve(cwd, "worker.ts");
+  const mainTsPath = path16.resolve(cwd, "src/main.ts");
+  const configPath = path16.resolve(cwd, "codegen.config.yaml");
+  const schemaPath = path16.resolve(
     subsystemsRoot,
     "jobs",
     "job-orchestration.schema.ts"
@@ -10199,7 +10435,7 @@ function resolveJobsScaffoldLocals(input) {
   const mainContent = readFile(mainTsPath);
   const mainHookInjected = mainContent !== null && mainContent.includes(MAIN_HOOK_SENTINEL);
   return {
-    appName: path15.basename(cwd),
+    appName: path16.basename(cwd),
     workerMode: normaliseWorkerMode(jobsBlock.worker_mode),
     multiTenant: normaliseMultiTenant2(jobsBlock.multi_tenant),
     mainTsPath,
@@ -10241,20 +10477,20 @@ function localsToHygenArgs2(locals) {
 }
 
 // src/cli/shared/integration-scaffold-locals.ts
-import path16 from "path";
+import path17 from "path";
 function resolveIntegrationScaffoldLocals(input) {
   const { cwd, config } = input;
   void input.fileExists;
   const integrationBlock = config?.integration ?? {};
   const subsystemsRoot = resolveSubsystemsRootFromConfig(cwd, config);
-  const configPath = path16.resolve(cwd, "codegen.config.yaml");
-  const schemaPath = path16.resolve(
+  const configPath = path17.resolve(cwd, "codegen.config.yaml");
+  const schemaPath = path17.resolve(
     subsystemsRoot,
     "integration",
     "integration-audit.schema.ts"
   );
   return {
-    appName: path16.basename(cwd),
+    appName: path17.basename(cwd),
     multiTenant: normaliseMultiTenant3(integrationBlock.multi_tenant),
     configPath,
     schemaPath
@@ -10277,21 +10513,21 @@ function localsToHygenArgs3(locals) {
 }
 
 // src/cli/shared/bridge-scaffold-locals.ts
-import path17 from "path";
+import path18 from "path";
 function resolveBridgeScaffoldLocals(input) {
   const { cwd, config } = input;
   void input.fileExists;
   const bridgeBlock = config?.bridge ?? {};
   const subsystemsRoot = resolveSubsystemsRootFromConfig(cwd, config);
-  const configPath = path17.resolve(cwd, "codegen.config.yaml");
-  const generatedKeepPath = path17.resolve(
+  const configPath = path18.resolve(cwd, "codegen.config.yaml");
+  const generatedKeepPath = path18.resolve(
     subsystemsRoot,
     "bridge",
     "generated",
     ".gitkeep"
   );
   return {
-    appName: path17.basename(cwd),
+    appName: path18.basename(cwd),
     multiTenant: normaliseMultiTenant4(bridgeBlock.multi_tenant),
     configPath,
     generatedKeepPath
@@ -10314,19 +10550,19 @@ function localsToHygenArgs4(locals) {
 }
 
 // src/cli/shared/observability-scaffold-locals.ts
-import path18 from "path";
+import path19 from "path";
 var FALLBACK_BACKEND_SRC2 = "src";
 function resolveObservabilityScaffoldLocals(input) {
   const { cwd, config } = input;
   void input.fileExists;
   const backendSrc = typeof config?.paths?.backend_src === "string" && config.paths.backend_src.length > 0 ? config.paths.backend_src : FALLBACK_BACKEND_SRC2;
-  const appModulePath = path18.resolve(cwd, backendSrc, "app.module.ts");
-  const configPath = path18.resolve(cwd, "codegen.config.yaml");
+  const appModulePath = path19.resolve(cwd, backendSrc, "app.module.ts");
+  const configPath = path19.resolve(cwd, "codegen.config.yaml");
   const obsBlock = config?.observability ?? {};
   const reporters = obsBlock.reporters ?? {};
   const bridgeMetrics = reporters.bridgeMetrics ?? {};
   return {
-    appName: path18.basename(cwd),
+    appName: path19.basename(cwd),
     appModulePath,
     configPath,
     bridgeMetricsEnabled: bridgeMetrics.enabled === true
@@ -10347,7 +10583,7 @@ function localsToHygenArgs5(locals) {
 
 // src/cli/shared/auth-scaffold-locals.ts
 import crypto2 from "crypto";
-import path19 from "path";
+import path20 from "path";
 var FALLBACK_BACKEND_SRC3 = "src";
 var DEFAULT_REDIRECT_URI_BASE = "http://localhost:3000";
 function resolveAuthScaffoldLocals(input) {
@@ -10359,15 +10595,15 @@ function resolveAuthScaffoldLocals(input) {
   const redirectUriBase = typeof redirectRaw === "string" && redirectRaw.length > 0 ? redirectRaw : DEFAULT_REDIRECT_URI_BASE;
   const tokenEncryptionKey = crypto2.randomBytes(32).toString("base64");
   return {
-    appName: path19.basename(cwd),
-    configPath: path19.resolve(cwd, "codegen.config.yaml"),
-    schemaPath: path19.resolve(
+    appName: path20.basename(cwd),
+    configPath: path20.resolve(cwd, "codegen.config.yaml"),
+    schemaPath: path20.resolve(
       subsystemsRoot,
       "auth",
       "auth-oauth-state.schema.ts"
     ),
-    appModulePath: path19.resolve(cwd, backendSrc, "app.module.ts"),
-    envConfigPath: path19.resolve(cwd, ".env.config"),
+    appModulePath: path20.resolve(cwd, backendSrc, "app.module.ts"),
+    envConfigPath: path20.resolve(cwd, ".env.config"),
     redirectUriBase,
     tokenEncryptionKey
   };
@@ -10392,7 +10628,7 @@ function localsToHygenArgs6(locals) {
 }
 
 // src/cli/shared/auth-integrations-scaffold-locals.ts
-import path20 from "path";
+import path21 from "path";
 var FALLBACK_BACKEND_SRC4 = "src";
 var DEFAULT_MODULES_DIR = "modules";
 var DEFAULT_DEFINITIONS_DIR = "definitions/entities";
@@ -10401,17 +10637,17 @@ function resolveAuthIntegrationsScaffoldLocals(input) {
   const backendSrc = typeof config?.paths?.backend_src === "string" && config.paths.backend_src.length > 0 ? config.paths.backend_src : FALLBACK_BACKEND_SRC4;
   const pathsAny = config?.paths;
   const modulesConfigured = pathsAny?.modules_dir;
-  const vendorRoot = typeof modulesConfigured === "string" && modulesConfigured.length > 0 ? path20.resolve(cwd, modulesConfigured) : path20.resolve(cwd, backendSrc, DEFAULT_MODULES_DIR);
+  const vendorRoot = typeof modulesConfigured === "string" && modulesConfigured.length > 0 ? path21.resolve(cwd, modulesConfigured) : path21.resolve(cwd, backendSrc, DEFAULT_MODULES_DIR);
   const entitiesConfigured = typeof pathsAny?.entities === "string" && pathsAny.entities.length > 0 ? pathsAny.entities : typeof pathsAny?.entities_dir === "string" && pathsAny.entities_dir.length > 0 ? pathsAny.entities_dir : null;
-  const definitionsPath = entitiesConfigured !== null ? path20.resolve(cwd, entitiesConfigured, "connection.yaml") : path20.resolve(cwd, DEFAULT_DEFINITIONS_DIR, "connection.yaml");
-  const appModulePath = path20.resolve(cwd, backendSrc, "app.module.ts");
+  const definitionsPath = entitiesConfigured !== null ? path21.resolve(cwd, entitiesConfigured, "connection.yaml") : path21.resolve(cwd, DEFAULT_DEFINITIONS_DIR, "connection.yaml");
+  const appModulePath = path21.resolve(cwd, backendSrc, "app.module.ts");
   let authModuleRegistered = false;
   const appModuleSource = input.readFile(appModulePath);
   if (appModuleSource && appModuleSource.includes("AuthModule.forRoot")) {
     authModuleRegistered = true;
   }
   return {
-    appName: path20.basename(cwd),
+    appName: path21.basename(cwd),
     appModulePath,
     vendorRoot,
     definitionsPath,
@@ -10428,11 +10664,11 @@ function localsToHygenArgs7(locals) {
 }
 
 // src/cli/shared/runtime-copier.ts
-import fs10 from "fs";
-import path21 from "path";
+import fs11 from "fs";
+import path22 from "path";
 function readIfExists(p) {
   try {
-    return fs10.readFileSync(p, "utf-8");
+    return fs11.readFileSync(p, "utf-8");
   } catch {
     return null;
   }
@@ -10447,20 +10683,20 @@ function extractRelativeImports(source) {
   return out;
 }
 function resolveSourceImport(sourceFile, specifier) {
-  const base = path21.resolve(path21.dirname(sourceFile), specifier);
-  const candidates = [base + ".ts", base + ".tsx", path21.join(base, "index.ts")];
+  const base = path22.resolve(path22.dirname(sourceFile), specifier);
+  const candidates = [base + ".ts", base + ".tsx", path22.join(base, "index.ts")];
   for (const c of candidates) {
-    if (fs10.existsSync(c)) return c;
+    if (fs11.existsSync(c)) return c;
   }
   return null;
 }
 async function copyRuntime(opts) {
   const { sourceDir, targetDir, filter, resolveDeps, dryRun, onlyExisting } = opts;
-  if (!fs10.existsSync(sourceDir) || !fs10.statSync(sourceDir).isDirectory()) {
+  if (!fs11.existsSync(sourceDir) || !fs11.statSync(sourceDir).isDirectory()) {
     throw new Error(`runtime source directory not found: ${sourceDir}`);
   }
-  const runtimeRoot4 = opts.runtimeRoot ? path21.resolve(opts.runtimeRoot) : path21.resolve(sourceDir, "..", "..");
-  const depsTargetRoot = opts.depsTargetRoot ?? path21.resolve(targetDir, "..");
+  const runtimeRoot4 = opts.runtimeRoot ? path22.resolve(opts.runtimeRoot) : path22.resolve(sourceDir, "..", "..");
+  const depsTargetRoot = opts.depsTargetRoot ?? path22.resolve(targetDir, "..");
   const result = {
     written: [],
     updated: [],
@@ -10470,9 +10706,9 @@ async function copyRuntime(opts) {
   };
   const queue = [];
   function walk(dir) {
-    for (const entry of fs10.readdirSync(dir)) {
-      const src = path21.join(dir, entry);
-      const stat = fs10.statSync(src);
+    for (const entry of fs11.readdirSync(dir)) {
+      const src = path22.join(dir, entry);
+      const stat = fs11.statSync(src);
       if (stat.isDirectory()) {
         if (entry === "generated") continue;
         walk(src);
@@ -10480,9 +10716,9 @@ async function copyRuntime(opts) {
       }
       if (!stat.isFile()) continue;
       if (!entry.endsWith(".ts") && !entry.endsWith(".tsx")) continue;
-      const rel2 = path21.relative(sourceDir, src);
+      const rel2 = path22.relative(sourceDir, src);
       if (filter && !filter(rel2) && !filter(entry)) continue;
-      queue.push({ src, dest: path21.join(targetDir, rel2), isDep: false });
+      queue.push({ src, dest: path22.join(targetDir, rel2), isDep: false });
     }
   }
   walk(sourceDir);
@@ -10491,10 +10727,10 @@ async function copyRuntime(opts) {
     const next = queue.shift();
     if (visited.has(next.src)) continue;
     visited.add(next.src);
-    if (onlyExisting && !fs10.existsSync(next.dest)) {
+    if (onlyExisting && !fs11.existsSync(next.dest)) {
       continue;
     }
-    const content = fs10.readFileSync(next.src, "utf-8");
+    const content = fs11.readFileSync(next.src, "utf-8");
     result.planned.push(next.dest);
     const existing = readIfExists(next.dest);
     const status = existing === content ? "unchanged" : existing === null ? "written" : "updated";
@@ -10503,18 +10739,18 @@ async function copyRuntime(opts) {
     else result.unchanged.push(next.dest);
     if (next.isDep) result.dependenciesCopied.push(next.dest);
     if (!dryRun && status !== "unchanged") {
-      fs10.mkdirSync(path21.dirname(next.dest), { recursive: true });
-      fs10.writeFileSync(next.dest, content);
+      fs11.mkdirSync(path22.dirname(next.dest), { recursive: true });
+      fs11.writeFileSync(next.dest, content);
     }
     if (resolveDeps) {
       for (const spec of extractRelativeImports(content)) {
         const resolvedSrc = resolveSourceImport(next.src, spec);
         if (!resolvedSrc) continue;
-        const relToRuntime = path21.relative(runtimeRoot4, resolvedSrc);
-        if (relToRuntime.startsWith("..") || path21.isAbsolute(relToRuntime)) continue;
-        const relToSource = path21.relative(sourceDir, resolvedSrc);
-        if (!relToSource.startsWith("..") && !path21.isAbsolute(relToSource)) continue;
-        const depDest = path21.join(depsTargetRoot, relToRuntime);
+        const relToRuntime = path22.relative(runtimeRoot4, resolvedSrc);
+        if (relToRuntime.startsWith("..") || path22.isAbsolute(relToRuntime)) continue;
+        const relToSource = path22.relative(sourceDir, resolvedSrc);
+        if (!relToSource.startsWith("..") && !path22.isAbsolute(relToSource)) continue;
+        const depDest = path22.join(depsTargetRoot, relToRuntime);
         queue.push({ src: resolvedSrc, dest: depDest, isDep: true });
       }
     }
@@ -10522,19 +10758,87 @@ async function copyRuntime(opts) {
   return result;
 }
 
+// src/cli/shared/subsystems-install-config.ts
+import fs12 from "fs";
+import path23 from "path";
+import yaml2 from "yaml";
+function readInstallList(config) {
+  const raw = config?.subsystems?.install;
+  if (!Array.isArray(raw)) return [];
+  return raw.filter((e) => typeof e === "string");
+}
+function ensureSubsystemInstalled(configPath, name) {
+  if (!fs12.existsSync(configPath)) {
+    fs12.mkdirSync(path23.dirname(configPath), { recursive: true });
+    fs12.writeFileSync(
+      configPath,
+      `subsystems:
+  install:
+    - ${name}
+`,
+      "utf-8"
+    );
+    return { outcome: "added", install: [name] };
+  }
+  const source = fs12.readFileSync(configPath, "utf-8");
+  let doc;
+  try {
+    doc = yaml2.parseDocument(source);
+    if (doc.errors.length > 0) {
+      return { outcome: "parse-error", install: [] };
+    }
+  } catch {
+    return { outcome: "parse-error", install: [] };
+  }
+  const current = readInstallList(
+    doc.toJS()
+  );
+  if (current.includes(name)) {
+    return { outcome: "already", install: current };
+  }
+  const subsystemsNode = doc.get("subsystems", true);
+  const installSeq = subsystemsNode && typeof subsystemsNode.get === "function" ? subsystemsNode.get("install", true) : void 0;
+  if (installSeq && Array.isArray(installSeq.items) && installSeq.items.length > 0) {
+    const lastItem = installSeq.items[installSeq.items.length - 1];
+    const range = lastItem.range;
+    if (range) {
+      const insertAt = range[1];
+      const lineStart = source.lastIndexOf("\n", range[0]) + 1;
+      const indent = source.slice(lineStart, range[0]).match(/^\s*/)?.[0] ?? "    ";
+      const before = source.slice(0, insertAt);
+      const after = source.slice(insertAt);
+      const next = `${before}
+${indent}- ${name}${after}`;
+      fs12.writeFileSync(configPath, next, "utf-8");
+      return { outcome: "added", install: [...current, name] };
+    }
+  }
+  doc.setIn(["subsystems", "install"], [...current, name]);
+  fs12.writeFileSync(configPath, String(doc), "utf-8");
+  return { outcome: "added", install: [...current, name] };
+}
+
 // src/cli/commands/subsystem.ts
 function runtimeRoot() {
-  const pkgRoot = path22.resolve(import.meta.dirname, "..", "..", "..");
-  const topLevel = path22.join(pkgRoot, "runtime");
-  if (fs11.existsSync(topLevel)) return topLevel;
-  return path22.join(pkgRoot, "dist", "runtime");
+  const pkgRoot = path24.resolve(import.meta.dirname, "..", "..", "..");
+  const topLevel = path24.join(pkgRoot, "runtime");
+  if (fs13.existsSync(topLevel)) return topLevel;
+  return path24.join(pkgRoot, "dist", "runtime");
 }
 function subsystemSource(name) {
-  return path22.join(runtimeRoot(), "subsystems", name);
+  return path24.join(runtimeRoot(), "subsystems", name);
 }
 function describeSubsystem(name) {
   return SUBSYSTEMS.find((s) => s.name === name) ?? null;
 }
+var PACKAGE_CONFIG_BLOCK = {
+  events: { detector: "events", actionFolder: "events-config" },
+  jobs: { detector: "jobs", actionFolder: "jobs-config" },
+  integration: { detector: "integration", actionFolder: "integration-config" },
+  bridge: { detector: "bridge", actionFolder: "bridge-config" },
+  observability: { detector: "observability", actionFolder: "observability-config" },
+  auth: { detector: "auth", actionFolder: "auth-config" }
+};
 async function summary2(ctx) {
   const installed = await detectInstalledSubsystems(ctx);
   const installedNames = new Set(installed.map((i) => i.name));
@@ -10557,7 +10861,7 @@ async function summary2(ctx) {
   }
   body.push(theme.muted("Installed:"));
   for (const i of installed) {
-    const rel2 = path22.relative(ctx.cwd, i.path) || i.path;
+    const rel2 = path24.relative(ctx.cwd, i.path) || i.path;
     body.push(
       `  ${theme.success(icons.check)} ${i.name.padEnd(10)} ${theme.muted(
         `${i.backend} backend`
@@ -10680,6 +10984,9 @@ var SubsystemInstallCommand = class extends Command3 {
     if (desc3.name === "auth-integrations") {
       return this.executeAuthIntegrations(ctx);
     }
+    if (resolveRuntimeMode(ctx.config) === "package") {
+      return this.executePackageMode(ctx, desc3, backend);
+    }
     const installed = await detectInstalledSubsystems(ctx);
     const already = installed.find((i) => i.name === desc3.name);
     if (already && !this.force) {
@@ -10697,14 +11004,14 @@ var SubsystemInstallCommand = class extends Command3 {
       return 0;
     }
     const targetRoot = resolveSubsystemsRoot(ctx, this.target);
-    const subsystemTarget = path22.join(targetRoot, desc3.name);
+    const subsystemTarget = path24.join(targetRoot, desc3.name);
     const source = subsystemSource(desc3.name);
-    if (!fs11.existsSync(source)) {
+    if (!fs13.existsSync(source)) {
       printError(`Runtime subsystem source missing: ${source}`);
       return 1;
     }
     if (!this.force) {
-      const gitCheck = checkGitSafety([path22.relative(ctx.cwd, subsystemTarget) || subsystemTarget], ctx.cwd);
+      const gitCheck = checkGitSafety([path24.relative(ctx.cwd, subsystemTarget) || subsystemTarget], ctx.cwd);
       if (gitCheck.inRepo && !gitCheck.clean) {
         printWarning(
           `Uncommitted changes under ${subsystemTarget}. Pass --force to overwrite.`
@@ -10713,7 +11020,7 @@ var SubsystemInstallCommand = class extends Command3 {
       }
     }
     if (!isJsonMode()) {
-      printInfo(`target = ${path22.relative(ctx.cwd, subsystemTarget) || subsystemTarget}`);
+      printInfo(`target = ${path24.relative(ctx.cwd, subsystemTarget) || subsystemTarget}`);
       printInfo(`backend = ${backend}`);
     }
     const result = await copyRuntime({
@@ -10722,7 +11029,7 @@ var SubsystemInstallCommand = class extends Command3 {
       filter: backendFileFilter(backend, desc3.name),
       resolveDeps: true,
       runtimeRoot: runtimeRoot(),
-      depsTargetRoot: path22.resolve(targetRoot, ".."),
+      depsTargetRoot: path24.resolve(targetRoot, ".."),
       dryRun: this.dryRun
     });
     const jobsScaffold = desc3.name === "jobs" ? runJobsScaffold(ctx.cwd, ctx.config, {
@@ -10817,14 +11124,14 @@ var SubsystemInstallCommand = class extends Command3 {
     if (this.dryRun) {
       printInfo(`Dry run \u2014 ${result.planned.length} files would be written`);
       for (const p of result.planned) {
-        console.log(`  ${theme.muted(icons.arrow)} ${path22.relative(ctx.cwd, p) || p}`);
+        console.log(`  ${theme.muted(icons.arrow)} ${path24.relative(ctx.cwd, p) || p}`);
       }
       if (jobsScaffold?.planned?.length) {
         printInfo(
           `Jobs scaffold \u2014 ${jobsScaffold.planned.length} template targets`
         );
         for (const p of jobsScaffold.planned) {
-          console.log(`  ${theme.muted(icons.arrow)} ${path22.relative(ctx.cwd, p) || p}`);
+          console.log(`  ${theme.muted(icons.arrow)} ${path24.relative(ctx.cwd, p) || p}`);
         }
       }
       if (eventsScaffold?.planned?.length) {
@@ -10832,7 +11139,7 @@ var SubsystemInstallCommand = class extends Command3 {
           `Events scaffold \u2014 ${eventsScaffold.planned.length} template targets`
         );
         for (const p of eventsScaffold.planned) {
-          console.log(`  ${theme.muted(icons.arrow)} ${path22.relative(ctx.cwd, p) || p}`);
+          console.log(`  ${theme.muted(icons.arrow)} ${path24.relative(ctx.cwd, p) || p}`);
         }
       }
       if (integrationScaffold?.planned?.length) {
@@ -10840,7 +11147,7 @@ var SubsystemInstallCommand = class extends Command3 {
           `Integration scaffold \u2014 ${integrationScaffold.planned.length} template targets`
         );
         for (const p of integrationScaffold.planned) {
-          console.log(`  ${theme.muted(icons.arrow)} ${path22.relative(ctx.cwd, p) || p}`);
+          console.log(`  ${theme.muted(icons.arrow)} ${path24.relative(ctx.cwd, p) || p}`);
         }
       }
       if (bridgeScaffold?.planned?.length) {
@@ -10848,7 +11155,7 @@ var SubsystemInstallCommand = class extends Command3 {
           `Bridge scaffold \u2014 ${bridgeScaffold.planned.length} template targets`
         );
         for (const p of bridgeScaffold.planned) {
-          console.log(`  ${theme.muted(icons.arrow)} ${path22.relative(ctx.cwd, p) || p}`);
+          console.log(`  ${theme.muted(icons.arrow)} ${path24.relative(ctx.cwd, p) || p}`);
         }
       }
       if (observabilityScaffold?.planned?.length) {
@@ -10856,7 +11163,7 @@ var SubsystemInstallCommand = class extends Command3 {
           `Observability scaffold \u2014 ${observabilityScaffold.planned.length} template targets`
         );
         for (const p of observabilityScaffold.planned) {
-          console.log(`  ${theme.muted(icons.arrow)} ${path22.relative(ctx.cwd, p) || p}`);
+          console.log(`  ${theme.muted(icons.arrow)} ${path24.relative(ctx.cwd, p) || p}`);
         }
       }
       if (authScaffold?.planned?.length) {
@@ -10864,7 +11171,7 @@ var SubsystemInstallCommand = class extends Command3 {
           `Auth scaffold \u2014 ${authScaffold.planned.length} template targets`
         );
         for (const p of authScaffold.planned) {
-          console.log(`  ${theme.muted(icons.arrow)} ${path22.relative(ctx.cwd, p) || p}`);
+          console.log(`  ${theme.muted(icons.arrow)} ${path24.relative(ctx.cwd, p) || p}`);
         }
       }
       return 0;
@@ -10973,6 +11280,143 @@ var SubsystemInstallCommand = class extends Command3 {
     }
     return 0;
   }
+  /**
+   * ADR-037: package-mode install. The subsystem runtime lives in the
+   * published `@pattern-stack/codegen` package, so installing reduces to a
+   * config + barrel operation with NO file vendoring:
+   *
+   *   1. record the name under `subsystems.install` (the package-mode
+   *      source of truth for "installed");
+   *   2. inject the per-subsystem `<name>:` config block via the same Hygen
+   *      action vendored mode uses (the block is runtime-agnostic — it only
+   *      writes YAML, never code); cache/storage have no config block, so this
+   *      step is skipped for them;
+   *   3. regenerate the composition barrel (`<generated>/subsystems.ts`) and
+   *      the schema barrel (`<generated>/subsystems-schema.ts`) so AppModule's
+   *      `...SUBSYSTEM_MODULES` and drizzle-kit's schema pick up the new
+   *      install.
+   *
+   * Idempotent: a name already in `subsystems.install` is a no-op unless
+   * `--force` is passed (which still re-runs config-block injection under
+   * `--force-config` and always regenerates the barrels).
+   */
+  async executePackageMode(ctx, desc3, backend) {
+    const configPath = path24.join(ctx.cwd, "codegen.config.yaml");
+    const installed = configuredSubsystemNames(
+      ctx.config
+    );
+    const already = installed.includes(desc3.name);
+    if (already && !this.force) {
+      if (isJsonMode()) {
+        printJson({
+          command: "subsystem install",
+          subsystem: desc3.name,
+          runtime: "package",
+          status: "already-installed"
+        });
+      } else {
+        printInfo(
+          `${desc3.name} is already in subsystems.install (runtime: package \u2014 nothing to vendor). Pass --force to refresh the config block + barrels.`
+        );
+      }
+      return 0;
+    }
+    const configSubsystem = PACKAGE_CONFIG_BLOCK[desc3.name];
+    const configBlockOutcome = configSubsystem ? planConfigBlockAction(configPath, configSubsystem.detector, this.forceConfig) : null;
+    if (configBlockOutcome === "parse-error") {
+      printError(
+        `codegen.config.yaml is not valid YAML: refusing to inject ${desc3.name} config block. Fix the YAML and re-run.`
+      );
+      return 1;
+    }
+    if (this.dryRun) {
+      if (isJsonMode()) {
+        printJson({
+          command: "subsystem install",
+          subsystem: desc3.name,
+          runtime: "package",
+          dryRun: true,
+          installList: already ? installed : [...installed, desc3.name],
+          configBlockOutcome
+        });
+      } else {
+        printInfo(`Dry run \u2014 runtime: package (no files vendored).`);
+        if (!already) printInfo(`  would add '${desc3.name}' to subsystems.install`);
+        if (configBlockOutcome) {
+          printInfo(`  ${desc3.name} config block would be ${configBlockOutcome}`);
+        }
+        printInfo("  would regenerate <generated>/subsystems.ts + subsystems-schema.ts");
+      }
+      return 0;
+    }
+    const installResult = ensureSubsystemInstalled(configPath, desc3.name);
+    if (installResult.outcome === "parse-error") {
+      printError(
+        "codegen.config.yaml is not valid YAML: refusing to update subsystems.install. Fix the YAML and re-run."
+      );
+      return 1;
+    }
+    if (configSubsystem && configBlockOutcome) {
+      const configResult = runConfigBlockAction({
+        cwd: ctx.cwd,
+        actionFolder: configSubsystem.actionFolder,
+        configPath,
+        subsystem: configSubsystem.detector,
+        outcome: configBlockOutcome,
+        json: isJsonMode()
+      });
+      if (!configResult.ok) {
+        printError(
+          `${desc3.name} config-block injection failed: ${configResult.error ?? "unknown error"}`
+        );
+        return 1;
+      }
+    }
+    const refreshed = await loadContext({
+      cwd: ctx.cwd,
+      configPath: this.configPath,
+      json: this.json,
+      skipDetection: true
+    });
+    let barrelEmitted = [];
+    let schemaEmitted = [];
+    try {
+      const generatedDir = resolveGeneratedDir(refreshed);
+      const barrel = await regenerateSubsystemBarrel({ ctx: refreshed, generatedDir });
+      barrelEmitted = barrel.emitted;
+      const schema = await regenerateSubsystemSchemaBarrel({ ctx: refreshed, generatedDir });
+      schemaEmitted = schema.emitted;
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      printWarning(`barrel regeneration failed \u2014 ${msg}`);
+    }
+    if (isJsonMode()) {
+      printJson({
+        command: "subsystem install",
+        subsystem: desc3.name,
+        runtime: "package",
+        backend,
+        vendored: false,
+        installList: installResult.install,
+        installOutcome: installResult.outcome,
+        configBlockOutcome,
+        barrelEmitted,
+        schemaEmitted
+      });
+      return 0;
+    }
+    printSuccess(`${desc3.name} installed (runtime: package \u2014 no files vendored).`);
+    if (installResult.outcome === "added") {
+      printInfo(`Added '${desc3.name}' to subsystems.install.`);
+    }
+    printInfo(
+      `Regenerated <generated>/subsystems.ts (${barrelEmitted.join(", ") || "none"}) + subsystems-schema.ts (${schemaEmitted.join(", ") || "none"}).`
+    );
+    printInfo(
+      "Wire once (if not already): `import { SUBSYSTEM_MODULES } from './generated/subsystems'` into AppModule, and `export * from './generated/subsystems-schema'` into your drizzle-kit schema entrypoint."
+    );
+    return 0;
+  }
   /**
    * OPENAPI-4: install flow for the config-only `openapi-config`
    * pseudo-subsystem.
@@ -10984,7 +11428,7 @@ var SubsystemInstallCommand = class extends Command3 {
    * semantics as jobs/events/integration/bridge.
    */
   async executeOpenApiConfig(ctx) {
-    const configPath = path22.join(ctx.cwd, "codegen.config.yaml");
+    const configPath = path24.join(ctx.cwd, "codegen.config.yaml");
     const outcome = planConfigBlockAction(configPath, "openapi", this.forceConfig);
     if (outcome === "parse-error") {
       printError(
@@ -11003,7 +11447,7 @@ var SubsystemInstallCommand = class extends Command3 {
         });
       } else {
         printInfo(`Dry run \u2014 openapi config block would be ${outcome}`);
-        console.log(`  ${theme.muted(icons.arrow)} ${path22.relative(ctx.cwd, configPath) || configPath}`);
+        console.log(`  ${theme.muted(icons.arrow)} ${path24.relative(ctx.cwd, configPath) || configPath}`);
       }
       return 0;
     }
@@ -11098,7 +11542,7 @@ var SubsystemInstallCommand = class extends Command3 {
       );
       for (const p of scaffold.planned) {
         console.log(
-          `  ${theme.muted(icons.arrow)} ${path22.relative(ctx.cwd, p) || p}`
+          `  ${theme.muted(icons.arrow)} ${path24.relative(ctx.cwd, p) || p}`
         );
       }
       return 0;
@@ -11122,10 +11566,10 @@ var SubsystemInstallCommand = class extends Command3 {
   }
 };
 function planConfigBlockAction(configPath, subsystem, forceConfig) {
-  if (!fs11.existsSync(configPath)) {
+  if (!fs13.existsSync(configPath)) {
     return "inject";
   }
-  const source = fs11.readFileSync(configPath, "utf-8");
+  const source = fs13.readFileSync(configPath, "utf-8");
   const state = detectConfigBlock(source, subsystem);
   if (state === "parse-error") return "parse-error";
   if (state === "missing") return "inject";
@@ -11148,9 +11592,9 @@ function runConfigBlockAction(input) {
         );
       }
       try {
-        const source = fs11.readFileSync(input.configPath, "utf-8");
+        const source = fs13.readFileSync(input.configPath, "utf-8");
         const stripped = stripConfigBlock(source, input.subsystem);
-        fs11.writeFileSync(input.configPath, stripped, "utf-8");
+        fs13.writeFileSync(input.configPath, stripped, "utf-8");
       } catch (err) {
         const message = err instanceof Error ? err.message : String(err);
         return { ok: false, error: `strip failed: ${message}` };
@@ -11188,8 +11632,8 @@ function runJobsScaffold(cwd, config, opts) {
   const locals = resolveJobsScaffoldLocals({
     cwd,
     config,
-    fileExists: (p) => fs11.existsSync(p),
-    readFile: (p) => fs11.existsSync(p) ? fs11.readFileSync(p, "utf-8") : null
+    fileExists: (p) => fs13.existsSync(p),
+    readFile: (p) => fs13.existsSync(p) ? fs13.readFileSync(p, "utf-8") : null
   });
   const planned = [
     ...!locals.workerExists ? [locals.workerPath] : [],
@@ -11246,7 +11690,7 @@ function runEventsScaffold(cwd, config, opts) {
   const locals = resolveEventsScaffoldLocals({
     cwd,
     config,
-    fileExists: (p) => fs11.existsSync(p)
+    fileExists: (p) => fs13.existsSync(p)
   });
   const planned = [
     locals.configPath,
@@ -11302,7 +11746,7 @@ function runIntegrationScaffold(cwd, config, opts) {
   const locals = resolveIntegrationScaffoldLocals({
     cwd,
     config,
-    fileExists: (p) => fs11.existsSync(p)
+    fileExists: (p) => fs13.existsSync(p)
   });
   const planned = [
     locals.configPath,
@@ -11357,7 +11801,7 @@ function runBridgeScaffold(cwd, config, opts) {
   const locals = resolveBridgeScaffoldLocals({
     cwd,
     config,
-    fileExists: (p) => fs11.existsSync(p)
+    fileExists: (p) => fs13.existsSync(p)
   });
   const planned = [
     locals.configPath,
@@ -11411,7 +11855,7 @@ function runObservabilityScaffold(cwd, config, opts) {
   const locals = resolveObservabilityScaffoldLocals({
     cwd,
     config,
-    fileExists: (p) => fs11.existsSync(p)
+    fileExists: (p) => fs13.existsSync(p)
   });
   const planned = [locals.configPath, locals.appModulePath];
   const configBlockOutcome = planConfigBlockAction(
@@ -11480,9 +11924,9 @@ function runAuthScaffold(cwd, config, opts) {
   if (opts.dryRun) {
     return { ok: true, planned, configBlockOutcome };
   }
-  if (!fs11.existsSync(locals.envConfigPath)) {
-    fs11.mkdirSync(path22.dirname(locals.envConfigPath), { recursive: true });
-    fs11.writeFileSync(locals.envConfigPath, "", "utf-8");
+  if (!fs13.existsSync(locals.envConfigPath)) {
+    fs13.mkdirSync(path24.dirname(locals.envConfigPath), { recursive: true });
+    fs13.writeFileSync(locals.envConfigPath, "", "utf-8");
   }
   const result = invokeHygen({
     generator: "subsystem",
@@ -11518,57 +11962,57 @@ function runAuthScaffold(cwd, config, opts) {
   return { ok: true, planned, configBlockOutcome };
 }
 function authIntegrationsExamplesRoot() {
-  const pkgRoot = path22.resolve(import.meta.dirname, "..", "..", "..");
-  const topLevel = path22.join(pkgRoot, "examples", "auth-integrations");
-  if (fs11.existsSync(topLevel)) return topLevel;
-  return path22.join(pkgRoot, "dist", "examples", "auth-integrations");
+  const pkgRoot = path24.resolve(import.meta.dirname, "..", "..", "..");
+  const topLevel = path24.join(pkgRoot, "examples", "auth-integrations");
+  if (fs13.existsSync(topLevel)) return topLevel;
+  return path24.join(pkgRoot, "dist", "examples", "auth-integrations");
 }
 function copyTreeIdempotent(srcDir, destDir, force, transform) {
   const written = [];
   const skipped = [];
   const walk = (src, dest) => {
-    const entries = fs11.readdirSync(src, { withFileTypes: true });
+    const entries = fs13.readdirSync(src, { withFileTypes: true });
     for (const entry of entries) {
-      const srcPath = path22.join(src, entry.name);
-      const destPath = path22.join(dest, entry.name);
+      const srcPath = path24.join(src, entry.name);
+      const destPath = path24.join(dest, entry.name);
       if (entry.isDirectory()) {
-        fs11.mkdirSync(destPath, { recursive: true });
+        fs13.mkdirSync(destPath, { recursive: true });
         walk(srcPath, destPath);
         continue;
       }
       if (!entry.isFile()) continue;
-      if (fs11.existsSync(destPath) && !force) {
+      if (fs13.existsSync(destPath) && !force) {
         skipped.push(destPath);
         continue;
       }
-      fs11.mkdirSync(path22.dirname(destPath), { recursive: true });
+      fs13.mkdirSync(path24.dirname(destPath), { recursive: true });
       const isTextSource = transform && (entry.name.endsWith(".ts") || entry.name.endsWith(".tsx"));
       if (isTextSource && transform) {
-        const raw = fs11.readFileSync(srcPath, "utf-8");
-        fs11.writeFileSync(destPath, transform(raw, destPath), "utf-8");
+        const raw = fs13.readFileSync(srcPath, "utf-8");
+        fs13.writeFileSync(destPath, transform(raw, destPath), "utf-8");
       } else {
-        fs11.copyFileSync(srcPath, destPath);
+        fs13.copyFileSync(srcPath, destPath);
       }
       written.push(destPath);
     }
   };
-  if (!fs11.existsSync(srcDir)) return { written, skipped };
-  fs11.mkdirSync(destDir, { recursive: true });
+  if (!fs13.existsSync(srcDir)) return { written, skipped };
+  fs13.mkdirSync(destDir, { recursive: true });
   walk(srcDir, destDir);
   return { written, skipped };
 }
 var AUTH_BARE_IMPORT_RE = /(['"])@pattern-stack\/codegen\/runtime\/subsystems\/auth\1/g;
 function buildAuthImportRewriter(subsystemsRoot) {
-  const authRoot = path22.join(subsystemsRoot, "auth");
+  const authRoot = path24.join(subsystemsRoot, "auth");
   return (content, destPath) => {
     if (!AUTH_BARE_IMPORT_RE.test(content)) {
       AUTH_BARE_IMPORT_RE.lastIndex = 0;
       return content;
     }
     AUTH_BARE_IMPORT_RE.lastIndex = 0;
-    let rel2 = path22.relative(path22.dirname(destPath), authRoot);
+    let rel2 = path24.relative(path24.dirname(destPath), authRoot);
     if (!rel2.startsWith(".")) rel2 = `./${rel2}`;
-    const relPosix = rel2.split(path22.sep).join("/");
+    const relPosix = rel2.split(path24.sep).join("/");
     return content.replace(
       AUTH_BARE_IMPORT_RE,
       (_match, quote) => `${quote}${relPosix}${quote}`
@@ -11579,20 +12023,20 @@ function runAuthIntegrationsScaffold(cwd, config, opts) {
   const locals = resolveAuthIntegrationsScaffoldLocals({
     cwd,
     config,
-    fileExists: (p) => fs11.existsSync(p),
-    readFile: (p) => fs11.existsSync(p) ? fs11.readFileSync(p, "utf-8") : null
+    fileExists: (p) => fs13.existsSync(p),
+    readFile: (p) => fs13.existsSync(p) ? fs13.readFileSync(p, "utf-8") : null
   });
   const examplesRoot = authIntegrationsExamplesRoot();
-  if (!fs11.existsSync(examplesRoot)) {
+  if (!fs13.existsSync(examplesRoot)) {
     return {
       ok: false,
       planned: [],
       error: `auth-integrations starter source missing: ${examplesRoot}`
     };
   }
-  const adaptersSrc = path22.join(examplesRoot, "runtime", "connections");
-  const adaptersDest = path22.join(locals.vendorRoot, "connections");
-  const connectionYamlSrc = path22.join(
+  const adaptersSrc = path24.join(examplesRoot, "runtime", "connections");
+  const adaptersDest = path24.join(locals.vendorRoot, "connections");
+  const connectionYamlSrc = path24.join(
     examplesRoot,
     "definitions",
     "entities",
@@ -11621,11 +12065,11 @@ function runAuthIntegrationsScaffold(cwd, config, opts) {
   let yamlWritten = false;
   let yamlSkipped = false;
   try {
-    if (fs11.existsSync(connectionYamlDest) && !opts.force) {
+    if (fs13.existsSync(connectionYamlDest) && !opts.force) {
       yamlSkipped = true;
-    } else if (fs11.existsSync(connectionYamlSrc)) {
-      fs11.mkdirSync(path22.dirname(connectionYamlDest), { recursive: true });
-      fs11.copyFileSync(connectionYamlSrc, connectionYamlDest);
+    } else if (fs13.existsSync(connectionYamlSrc)) {
+      fs13.mkdirSync(path24.dirname(connectionYamlDest), { recursive: true });
+      fs13.copyFileSync(connectionYamlSrc, connectionYamlDest);
       yamlWritten = true;
     }
   } catch (err) {
@@ -11690,7 +12134,7 @@ var SubsystemListCommand = class extends Command3 {
         name: s.name,
         status: inst ? inst.status : "available",
         backend: inst ? inst.backend : null,
-        path: inst ? path22.relative(ctx.cwd, inst.path) || inst.path : null
+        path: inst ? path24.relative(ctx.cwd, inst.path) || inst.path : null
       };
     });
     if (isJsonMode()) {
@@ -11779,14 +12223,14 @@ var SubsystemRemoveCommand = class extends Command3 {
       return 1;
     }
     const subsystemDir = target.path;
-    if (!fs11.existsSync(subsystemDir)) {
+    if (!fs13.existsSync(subsystemDir)) {
       printError(
         `Detected install at ${subsystemDir} but the directory is gone \u2014 refusing to act.`
       );
       return 1;
     }
     if (!this.force) {
-      const rel2 = path22.relative(ctx.cwd, subsystemDir) || subsystemDir;
+      const rel2 = path24.relative(ctx.cwd, subsystemDir) || subsystemDir;
       const gitCheck = checkGitSafety([rel2], ctx.cwd);
       if (gitCheck.inRepo && !gitCheck.clean) {
         printWarning(
@@ -11796,7 +12240,7 @@ var SubsystemRemoveCommand = class extends Command3 {
       }
     }
     try {
-      fs11.rmSync(subsystemDir, { recursive: true, force: true });
+      fs13.rmSync(subsystemDir, { recursive: true, force: true });
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
       printError(`Failed to remove ${subsystemDir}: ${message}`);
@@ -11822,7 +12266,7 @@ var SubsystemRemoveCommand = class extends Command3 {
       return 0;
     }
     printSuccess(
-      `${desc3.name} subsystem removed (${path22.relative(ctx.cwd, subsystemDir) || subsystemDir}).`
+      `${desc3.name} subsystem removed (${path24.relative(ctx.cwd, subsystemDir) || subsystemDir}).`
     );
     if (barrelRegenerated) {
       printInfo("Regenerated <generated>/subsystems.ts barrel.");
@@ -11850,28 +12294,28 @@ var subsystemNoun = {
 var subsystem_default = subsystemNoun;
 
 // src/cli/commands/project.ts
-import fs17 from "fs";
-import path28 from "path";
+import fs19 from "fs";
+import path30 from "path";
 import readline from "readline";
 import { Command as Command7, Option as Option7 } from "clipanion";
 import { stringify as stringifyYaml2 } from "yaml";
 
 // src/cli/shared/init-scaffold.ts
-import fs12 from "fs";
-import path23 from "path";
+import fs14 from "fs";
+import path25 from "path";
 import { stringify as stringifyYaml } from "yaml";
 function runtimeRoot2() {
-  const pkgRoot = path23.resolve(import.meta.dirname, "..", "..", "..");
-  const topLevel = path23.join(pkgRoot, "runtime");
-  if (fs12.existsSync(topLevel)) return topLevel;
-  return path23.join(pkgRoot, "dist", "runtime");
+  const pkgRoot = path25.resolve(import.meta.dirname, "..", "..", "..");
+  const topLevel = path25.join(pkgRoot, "runtime");
+  if (fs14.existsSync(topLevel)) return topLevel;
+  return path25.join(pkgRoot, "dist", "runtime");
 }
 function resolveRuntimePath(cwd) {
-  const shimDir = path23.join(cwd, "src", "shared", "base-classes");
-  return path23.relative(shimDir, runtimeRoot2());
+  const shimDir = path25.join(cwd, "src", "shared", "base-classes");
+  return path25.relative(shimDir, runtimeRoot2());
 }
 function loadRuntimeFile(relPath2) {
-  return fs12.readFileSync(path23.join(runtimeRoot2(), relPath2), "utf-8");
+  return fs14.readFileSync(path25.join(runtimeRoot2(), relPath2), "utf-8");
 }
 var VENDORED_RUNTIME_FILES = [
   // base-classes — consumer-facing inheritance targets
@@ -11920,12 +12364,13 @@ var VENDORED_RUNTIME_FILES = [
   },
   { runtime: "shared/openapi/index.ts", target: "src/shared/openapi/index.ts" }
 ];
-function databaseModuleContent() {
+function databaseModuleContent(mode) {
+  const drizzleTokenImport = mode === "vendored" ? "../constants/tokens" : runtimeImport(mode, "constants/tokens");
   return `import { Module, Global } from '@nestjs/common';
 import { drizzle } from 'drizzle-orm/node-postgres';
 import { Pool } from 'pg';
 import * as schema from '../../schema';
-import { DRIZZLE } from '../constants/tokens';
+import { DRIZZLE } from '${drizzleTokenImport}';
 
 export { DRIZZLE };
 export type DrizzleDB = ReturnType<typeof drizzle<typeof schema>>;
@@ -11952,11 +12397,12 @@ export type DrizzleDB = ReturnType<typeof drizzle<typeof schema>>;
 export class DatabaseModule {}
 `;
 }
-function appModuleContent() {
+function appModuleContent(mode) {
+  const openApiImport = mode === "vendored" ? "./shared/openapi" : runtimeImport(mode, "shared/openapi");
   return `import { Global, Module } from '@nestjs/common';
 import { DatabaseModule } from './shared/database/database.module';
 import { GENERATED_MODULES } from './generated/modules';
-import { OPENAPI_REGISTRY, OpenApiRegistry } from './shared/openapi';
+import { OPENAPI_REGISTRY, OpenApiRegistry } from '${openApiImport}';
 
 /**
  * OpenApiModule \u2014 @Global() wrapper around the OPENAPI_REGISTRY singleton.
@@ -11998,7 +12444,8 @@ class OpenApiModule {}
 export class AppModule {}
 `;
 }
-function mainTsContent() {
+function mainTsContent(mode) {
+  const openApiImport = mode === "vendored" ? "./shared/openapi" : runtimeImport(mode, "shared/openapi");
   return `import 'reflect-metadata';
 import fs from 'node:fs';
 import path from 'node:path';
@@ -12006,7 +12453,7 @@ import { NestFactory } from '@nestjs/core';
 import { DocumentBuilder, SwaggerModule } from '@nestjs/swagger';
 import { parse as parseYaml } from 'yaml';
 import { AppModule } from './app.module';
-import { OPENAPI_REGISTRY, OpenApiRegistry } from './shared/openapi';
+import { OPENAPI_REGISTRY, OpenApiRegistry } from '${openApiImport}';
 
 interface OpenApiConfig {
   enabled?: boolean;
@@ -12285,10 +12732,10 @@ function mergeTsconfig(raw) {
   };
 }
 function relOf(cwd, abs) {
-  return path23.relative(cwd, abs) || abs;
+  return path25.relative(cwd, abs) || abs;
 }
 function fileEntry(cwd, absPath, content, opts) {
-  const exists = fs12.existsSync(absPath);
+  const exists = fs14.existsSync(absPath);
   let action;
   let reason = opts.skipReason;
   if (!exists) {
@@ -12303,7 +12750,7 @@ function fileEntry(cwd, absPath, content, opts) {
   return { path: absPath, relPath: relOf(cwd, absPath), action, content, reason };
 }
 function dirEntry(cwd, absPath) {
-  const exists = fs12.existsSync(absPath);
+  const exists = fs14.existsSync(absPath);
   return {
     path: absPath,
     relPath: relOf(cwd, absPath),
@@ -12315,6 +12762,7 @@ function dirEntry(cwd, absPath) {
 async function buildInitPlan(ctx, options) {
   const cwd = options.cwd;
   const force = Boolean(options.force);
+  const runtimeMode = options.runtimeMode === "vendored" ? "vendored" : "package";
   let framework = "nestjs";
   let orm = "drizzle";
   let architecture = "clean-lite-ps";
@@ -12335,8 +12783,13 @@ async function buildInitPlan(ctx, options) {
   const runtimePath = options.runtimePath ?? resolveRuntimePath(cwd);
   const entries = [];
   {
-    const configPath = path23.join(cwd, "codegen.config.yaml");
+    const configPath = path25.join(cwd, "codegen.config.yaml");
     const config = {
+      // Runtime mode (ADR-037). `package` (default) imports the runtime from
+      // `@pattern-stack/codegen/*`; `vendored` imports it via `@shared/*` and
+      // vendors `src/shared/**`. Existing vendored projects MUST set this to
+      // `vendored` explicitly — the default does not silently flip them.
+      runtime: runtimeMode,
       paths: {
         backend_src: "src",
         entities_dir: "entities",
@@ -12365,9 +12818,9 @@ async function buildInitPlan(ctx, options) {
     entries.push(fileEntry(cwd, configPath, content, { force }));
   }
   {
-    const tsconfigPath = path23.join(cwd, "tsconfig.json");
-    if (fs12.existsSync(tsconfigPath)) {
-      const raw = fs12.readFileSync(tsconfigPath, "utf-8");
+    const tsconfigPath = path25.join(cwd, "tsconfig.json");
+    if (fs14.existsSync(tsconfigPath)) {
+      const raw = fs14.readFileSync(tsconfigPath, "utf-8");
       const merged = mergeTsconfig(raw);
       if (merged.parseError) {
         entries.push({
@@ -12412,20 +12865,22 @@ async function buildInitPlan(ctx, options) {
   entries.push(
     fileEntry(
       cwd,
-      path23.join(cwd, "src", "shared", "database", "database.module.ts"),
-      databaseModuleContent(),
+      path25.join(cwd, "src", "shared", "database", "database.module.ts"),
+      databaseModuleContent(runtimeMode),
       { force }
     )
   );
-  for (const v of VENDORED_RUNTIME_FILES) {
-    entries.push(
-      fileEntry(cwd, path23.join(cwd, v.target), loadRuntimeFile(v.runtime), { force })
-    );
+  if (runtimeMode === "vendored") {
+    for (const v of VENDORED_RUNTIME_FILES) {
+      entries.push(
+        fileEntry(cwd, path25.join(cwd, v.target), loadRuntimeFile(v.runtime), { force })
+      );
+    }
   }
   entries.push(
     fileEntry(
       cwd,
-      path23.join(cwd, "src", "generated", "modules.ts"),
+      path25.join(cwd, "src", "generated", "modules.ts"),
       emptyModulesBarrel(),
       { force }
     )
@@ -12433,19 +12888,19 @@ async function buildInitPlan(ctx, options) {
   entries.push(
     fileEntry(
       cwd,
-      path23.join(cwd, "src", "generated", "schema.ts"),
+      path25.join(cwd, "src", "generated", "schema.ts"),
       emptySchemaBarrel(),
       { force }
     )
   );
   {
-    const appModulePath = path23.join(cwd, "src", "app.module.ts");
-    if (!fs12.existsSync(appModulePath)) {
+    const appModulePath = path25.join(cwd, "src", "app.module.ts");
+    if (!fs14.existsSync(appModulePath)) {
       entries.push({
         path: appModulePath,
         relPath: relOf(cwd, appModulePath),
         action: "create",
-        content: appModuleContent()
+        content: appModuleContent(runtimeMode)
       });
     } else {
       entries.push({
@@ -12457,13 +12912,13 @@ async function buildInitPlan(ctx, options) {
     }
   }
   {
-    const mainPath = path23.join(cwd, "src", "main.ts");
-    if (!fs12.existsSync(mainPath)) {
+    const mainPath = path25.join(cwd, "src", "main.ts");
+    if (!fs14.existsSync(mainPath)) {
       entries.push({
         path: mainPath,
         relPath: relOf(cwd, mainPath),
         action: "create",
-        content: mainTsContent()
+        content: mainTsContent(runtimeMode)
       });
     } else {
       entries.push({
@@ -12475,8 +12930,8 @@ async function buildInitPlan(ctx, options) {
     }
   }
   {
-    const schemaPath = path23.join(cwd, "src", "schema.ts");
-    if (!fs12.existsSync(schemaPath)) {
+    const schemaPath = path25.join(cwd, "src", "schema.ts");
+    if (!fs14.existsSync(schemaPath)) {
       entries.push({
         path: schemaPath,
         relPath: relOf(cwd, schemaPath),
@@ -12492,14 +12947,14 @@ async function buildInitPlan(ctx, options) {
       });
     }
   }
-  entries.push(dirEntry(cwd, path23.join(cwd, "entities")));
+  entries.push(dirEntry(cwd, path25.join(cwd, "entities")));
   {
-    const entitiesDir = path23.join(cwd, "entities");
-    const examplePath = path23.join(entitiesDir, "example.yaml");
-    const hasOtherYamls = fs12.existsSync(entitiesDir) && findYamlFiles(entitiesDir).some(
-      (f) => path23.basename(f) !== "example.yaml"
+    const entitiesDir = path25.join(cwd, "entities");
+    const examplePath = path25.join(entitiesDir, "example.yaml");
+    const hasOtherYamls = fs14.existsSync(entitiesDir) && findYamlFiles(entitiesDir).some(
+      (f) => path25.basename(f) !== "example.yaml"
     );
-    if (fs12.existsSync(examplePath)) {
+    if (fs14.existsSync(examplePath)) {
       entries.push({
         path: examplePath,
         relPath: relOf(cwd, examplePath),
@@ -12545,7 +13000,7 @@ function writePlan(plan) {
       continue;
     }
     if (e.directory) {
-      fs12.mkdirSync(e.path, { recursive: true });
+      fs14.mkdirSync(e.path, { recursive: true });
       created.push(e);
       continue;
     }
@@ -12553,8 +13008,8 @@ function writePlan(plan) {
       skipped.push(e);
       continue;
     }
-    fs12.mkdirSync(path23.dirname(e.path), { recursive: true });
-    fs12.writeFileSync(e.path, e.content, "utf-8");
+    fs14.mkdirSync(path25.dirname(e.path), { recursive: true });
+    fs14.writeFileSync(e.path, e.content, "utf-8");
     if (e.action === "create") created.push(e);
     else if (e.action === "merge") merged.push(e);
     else if (e.action === "overwrite") overwritten.push(e);
@@ -12563,8 +13018,8 @@ function writePlan(plan) {
 }
 
 // src/cli/commands/project-upgrade-openapi.ts
-import fs13 from "fs";
-import path24 from "path";
+import fs15 from "fs";
+import path26 from "path";
 import { Command as Command4, Option as Option4 } from "clipanion";
 import { Project, IndentationText, QuoteKind, NewLineKind } from "ts-morph";
 
@@ -12803,35 +13258,35 @@ var MAIN_SWAGGER_IMPORTS = [
   "import { OPENAPI_REGISTRY, OpenApiRegistry } from './shared/openapi';"
 ];
 function runtimeRoot3() {
-  const pkgRoot = path24.resolve(import.meta.dirname, "..", "..", "..");
-  const topLevel = path24.join(pkgRoot, "runtime");
-  if (fs13.existsSync(topLevel)) return topLevel;
-  return path24.join(pkgRoot, "dist", "runtime");
+  const pkgRoot = path26.resolve(import.meta.dirname, "..", "..", "..");
+  const topLevel = path26.join(pkgRoot, "runtime");
+  if (fs15.existsSync(topLevel)) return topLevel;
+  return path26.join(pkgRoot, "dist", "runtime");
 }
 function loadRuntimeFile2(rel2) {
-  return fs13.readFileSync(path24.join(runtimeRoot3(), rel2), "utf-8");
+  return fs15.readFileSync(path26.join(runtimeRoot3(), rel2), "utf-8");
 }
 function resolveProjectRoot(startDir) {
-  let dir = path24.resolve(startDir);
+  let dir = path26.resolve(startDir);
   for (let i = 0; i < 16; i++) {
-    if (fs13.existsSync(path24.join(dir, "codegen.config.yaml")) || fs13.existsSync(path24.join(dir, "package.json"))) {
+    if (fs15.existsSync(path26.join(dir, "codegen.config.yaml")) || fs15.existsSync(path26.join(dir, "package.json"))) {
       return dir;
     }
-    const parent = path24.dirname(dir);
+    const parent = path26.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
-  return path24.resolve(startDir);
+  return path26.resolve(startDir);
 }
 async function runUpgradeOpenapi(opts) {
   const { projectRoot, dryRun, force } = opts;
   const changes = [];
   for (const v of OPENAPI_VENDORED_FILES) {
-    const target = path24.join(projectRoot, v.target);
-    const exists = fs13.existsSync(target);
+    const target = path26.join(projectRoot, v.target);
+    const exists = fs15.existsSync(target);
     const newContent = loadRuntimeFile2(v.runtime);
     if (exists && !force) {
-      const existing = fs13.readFileSync(target, "utf-8");
+      const existing = fs15.readFileSync(target, "utf-8");
       if (existing === newContent) {
         changes.push({ path: v.target, action: "unchanged" });
       } else {
@@ -12843,8 +13298,8 @@ async function runUpgradeOpenapi(opts) {
       }
     } else {
       if (!dryRun) {
-        fs13.mkdirSync(path24.dirname(target), { recursive: true });
-        fs13.writeFileSync(target, newContent);
+        fs15.mkdirSync(path26.dirname(target), { recursive: true });
+        fs15.writeFileSync(target, newContent);
       }
       changes.push({
         path: v.target,
@@ -12852,8 +13307,8 @@ async function runUpgradeOpenapi(opts) {
       });
     }
   }
-  const appModulePath = path24.join(projectRoot, "src", "app.module.ts");
-  if (!fs13.existsSync(appModulePath)) {
+  const appModulePath = path26.join(projectRoot, "src", "app.module.ts");
+  if (!fs15.existsSync(appModulePath)) {
     return {
       projectRoot,
       changes,
@@ -12936,8 +13391,8 @@ async function runUpgradeOpenapi(opts) {
   } else {
     changes.push({ path: "src/app.module.ts", action: "unchanged" });
   }
-  const mainPath = path24.join(projectRoot, "src", "main.ts");
-  if (fs13.existsSync(mainPath)) {
+  const mainPath = path26.join(projectRoot, "src", "main.ts");
+  if (fs15.existsSync(mainPath)) {
     const mainSource = project.addSourceFileAtPath(mainPath);
     const mainBefore = mainSource.getFullText();
     const result = ensureMainSwaggerBlock(mainSource, {
@@ -13017,8 +13472,8 @@ var ProjectUpgradeOpenapiCommand = class extends Command4 {
   json = Option4.Boolean("--json", false);
   async execute() {
     if (this.json) setJsonMode(true);
-    const startDir = this.pathOpt ? path24.resolve(this.pathOpt) : process.cwd();
-    if (!fs13.existsSync(startDir)) {
+    const startDir = this.pathOpt ? path26.resolve(this.pathOpt) : process.cwd();
+    if (!fs15.existsSync(startDir)) {
       printError(`Directory not found: ${startDir}`);
       return 1;
     }
@@ -13093,18 +13548,18 @@ ${CONSUMER_SETUP_POINTER}
 };
 
 // src/cli/commands/project-update.ts
-import fs16 from "fs";
-import path27 from "path";
+import fs18 from "fs";
+import path29 from "path";
 import { Command as Command6, Option as Option6 } from "clipanion";
 
 // src/cli/commands/skills.ts
-import fs15 from "fs";
-import path26 from "path";
+import fs17 from "fs";
+import path28 from "path";
 import { Command as Command5, Option as Option5 } from "clipanion";
 
 // src/cli/shared/tree-copier.ts
-import fs14 from "fs";
-import path25 from "path";
+import fs16 from "fs";
+import path27 from "path";
 var TEXT_EXTENSIONS = [".ts", ".tsx", ".md", ".mdx", ".yaml", ".yml", ".json"];
 function isTextFile(name) {
   return TEXT_EXTENSIONS.some((ext) => name.endsWith(ext));
@@ -13117,26 +13572,26 @@ function copyTreeWithReport(opts) {
     updated: [],
     unchanged: []
   };
-  if (!fs14.existsSync(srcDir) || !fs14.statSync(srcDir).isDirectory()) {
+  if (!fs16.existsSync(srcDir) || !fs16.statSync(srcDir).isDirectory()) {
     throw new Error(`tree-copier source directory not found: ${srcDir}`);
   }
   const walk = (relDir) => {
-    const absSrcDir = path25.join(srcDir, relDir);
-    for (const entry of fs14.readdirSync(absSrcDir, { withFileTypes: true })) {
-      const relPath2 = relDir ? path25.posix.join(relDir, entry.name) : entry.name;
-      const absSrc = path25.join(srcDir, relPath2);
+    const absSrcDir = path27.join(srcDir, relDir);
+    for (const entry of fs16.readdirSync(absSrcDir, { withFileTypes: true })) {
+      const relPath2 = relDir ? path27.posix.join(relDir, entry.name) : entry.name;
+      const absSrc = path27.join(srcDir, relPath2);
       if (entry.isDirectory()) {
         walk(relPath2);
         continue;
       }
       if (!entry.isFile()) continue;
       if (include && !include(relPath2)) continue;
-      const dest = path25.join(destDir, relPath2);
-      let content = fs14.readFileSync(absSrc, "utf-8");
+      const dest = path27.join(destDir, relPath2);
+      let content = fs16.readFileSync(absSrc, "utf-8");
       if (transform && isTextFile(entry.name)) {
         content = transform(content, dest);
       }
-      const existing = fs14.existsSync(dest) ? fs14.readFileSync(dest, "utf-8") : null;
+      const existing = fs16.existsSync(dest) ? fs16.readFileSync(dest, "utf-8") : null;
       let action;
       if (existing === null) {
         action = "created";
@@ -13146,8 +13601,8 @@ function copyTreeWithReport(opts) {
         action = "updated";
       }
       if (!dryRun && action !== "unchanged") {
-        fs14.mkdirSync(path25.dirname(dest), { recursive: true });
-        fs14.writeFileSync(dest, content, "utf-8");
+        fs16.mkdirSync(path27.dirname(dest), { recursive: true });
+        fs16.writeFileSync(dest, content, "utf-8");
       }
       const record = { relPath: relPath2, dest, action };
       report.entries.push(record);
@@ -13160,23 +13615,23 @@ function copyTreeWithReport(opts) {
 
 // src/cli/commands/skills.ts
 function consumerSkillsRoot() {
-  const pkgRoot = path26.resolve(import.meta.dirname, "..", "..", "..");
-  const topLevel = path26.join(pkgRoot, "consumer-skills");
-  if (fs15.existsSync(topLevel)) return topLevel;
-  return path26.join(pkgRoot, "dist", "consumer-skills");
+  const pkgRoot = path28.resolve(import.meta.dirname, "..", "..", "..");
+  const topLevel = path28.join(pkgRoot, "consumer-skills");
+  if (fs17.existsSync(topLevel)) return topLevel;
+  return path28.join(pkgRoot, "dist", "consumer-skills");
 }
 function skillsTargetDir(cwd) {
-  return path26.join(cwd, ".claude", "skills");
+  return path28.join(cwd, ".claude", "skills");
 }
 function availableSkills() {
   const root = consumerSkillsRoot();
-  if (!fs15.existsSync(root)) return [];
-  return fs15.readdirSync(root, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name).sort();
+  if (!fs17.existsSync(root)) return [];
+  return fs17.readdirSync(root, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name).sort();
 }
 function runSkillsInstall(opts) {
   const sourceRoot = consumerSkillsRoot();
   const targetDir = skillsTargetDir(opts.cwd);
-  if (!fs15.existsSync(sourceRoot)) {
+  if (!fs17.existsSync(sourceRoot)) {
     return {
       ok: false,
       sourceRoot,
@@ -13194,8 +13649,8 @@ function runSkillsInstall(opts) {
 async function summary3(ctx) {
   const skills = availableSkills();
   const targetDir = skillsTargetDir(ctx.cwd);
-  const installedDirs = fs15.existsSync(targetDir) ? new Set(
-    fs15.readdirSync(targetDir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name)
+  const installedDirs = fs17.existsSync(targetDir) ? new Set(
+    fs17.readdirSync(targetDir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name)
   ) : /* @__PURE__ */ new Set();
   const body = [];
   if (skills.length === 0) {
@@ -13213,13 +13668,13 @@ async function summary3(ctx) {
   return {
     title: "skills",
     body,
-    footer: `${installedCount} of ${skills.length} skills installed \u2192 ${path26.relative(ctx.cwd, targetDir) || targetDir}`
+    footer: `${installedCount} of ${skills.length} skills installed \u2192 ${path28.relative(ctx.cwd, targetDir) || targetDir}`
   };
 }
 async function hints3(ctx) {
   const skills = availableSkills();
   const targetDir = skillsTargetDir(ctx.cwd);
-  const allPresent = skills.length > 0 && fs15.existsSync(targetDir) && skills.every((s) => fs15.existsSync(path26.join(targetDir, s)));
+  const allPresent = skills.length > 0 && fs17.existsSync(targetDir) && skills.every((s) => fs17.existsSync(path28.join(targetDir, s)));
   if (allPresent) {
     return [
       { command: "codegen update", description: "Re-sync skills + runtime after a package bump" }
@@ -13294,7 +13749,7 @@ var SkillsInstallCommand = class extends Command5 {
       });
       return 0;
     }
-    printInfo(`target = ${path26.relative(ctx.cwd, result.targetDir) || result.targetDir}`);
+    printInfo(`target = ${path28.relative(ctx.cwd, result.targetDir) || result.targetDir}`);
     console.log("");
     renderTreeReport(report);
     console.log("");
@@ -13322,8 +13777,8 @@ var SkillsListCommand = class extends Command5 {
     const skills = availableSkills();
     const targetDir = skillsTargetDir(ctx.cwd);
     const rows = skills.map((name) => {
-      const dir = path26.join(targetDir, name);
-      return { name, status: fs15.existsSync(dir) ? "installed" : "available" };
+      const dir = path28.join(targetDir, name);
+      return { name, status: fs17.existsSync(dir) ? "installed" : "available" };
     });
     if (isJsonMode()) {
       printJson({ command: "skills list", target: targetDir, skills: rows });
@@ -13352,16 +13807,16 @@ var NON_RUNTIME_SUBSYSTEMS = /* @__PURE__ */ new Set(["openapi-config", "auth-in
 function syncVendoredRuntime(cwd, write) {
   const changes = [];
   for (const v of VENDORED_RUNTIME_FILES) {
-    const dest = path27.join(cwd, v.target);
+    const dest = path29.join(cwd, v.target);
     const content = loadRuntimeFile(v.runtime);
-    const existing = fs16.existsSync(dest) ? fs16.readFileSync(dest, "utf-8") : null;
+    const existing = fs18.existsSync(dest) ? fs18.readFileSync(dest, "utf-8") : null;
     let action;
     if (existing === null) action = "created";
     else if (existing === content) action = "unchanged";
     else action = "updated";
     if (write && action !== "unchanged") {
-      fs16.mkdirSync(path27.dirname(dest), { recursive: true });
-      fs16.writeFileSync(dest, content, "utf-8");
+      fs18.mkdirSync(path29.dirname(dest), { recursive: true });
+      fs18.writeFileSync(dest, content, "utf-8");
     }
     changes.push({ path: v.target, action });
   }
@@ -13372,17 +13827,17 @@ async function syncSubsystemRuntime(cwd, inst, write) {
     return { name: inst.name, changes: [], skippedReason: "config-only / vendored elsewhere" };
   }
   const source = subsystemSource(inst.name);
-  if (!fs16.existsSync(source)) {
+  if (!fs18.existsSync(source)) {
     return { name: inst.name, changes: [], skippedReason: "no runtime source in package" };
   }
-  const subsystemsRoot = path27.dirname(inst.path);
+  const subsystemsRoot = path29.dirname(inst.path);
   const result = await copyRuntime({
     sourceDir: source,
     targetDir: inst.path,
     filter: backendFileFilter(inst.backend, inst.name),
     resolveDeps: true,
     runtimeRoot: runtimeRoot2(),
-    depsTargetRoot: path27.resolve(subsystemsRoot, ".."),
+    depsTargetRoot: path29.resolve(subsystemsRoot, ".."),
     dryRun: !write,
     // Refresh files already vendored for this subsystem; never install new
     // ones (that's `subsystem install`). copyRuntime classifies accurately
@@ -13396,7 +13851,7 @@ async function syncSubsystemRuntime(cwd, inst, write) {
   return { name: inst.name, changes };
 }
 function rel(cwd, abs) {
-  return path27.relative(cwd, abs) || abs;
+  return path29.relative(cwd, abs) || abs;
 }
 var ProjectUpdateCommand = class extends Command6 {
   static paths = [["project", "update"]];
@@ -13435,7 +13890,7 @@ var ProjectUpdateCommand = class extends Command6 {
     const installed = this.skipSubsystems ? [] : await detectInstalledSubsystems(ctx);
     if (!this.dryRun && !this.force) {
       const vendoredDry = syncVendoredRuntime(ctx.cwd, false);
-      const vendoredDirtyCandidates = vendoredDry.filter((c) => c.action === "updated").map((c) => path27.join(ctx.cwd, c.path));
+      const vendoredDirtyCandidates = vendoredDry.filter((c) => c.action === "updated").map((c) => path29.join(ctx.cwd, c.path));
       const skillDirtyCandidates = this.skipSkills ? [] : runSkillsInstall({ cwd: ctx.cwd, dryRun: true }).report?.updated.map((e) => e.dest) ?? [];
       const subsystemDirs = installed.filter((i) => !NON_RUNTIME_SUBSYSTEMS.has(i.name)).map((i) => i.path);
       const gate = checkGitSafety(
@@ -13606,7 +14061,8 @@ var ProjectInitCommand = class extends Command7 {
   static usage = Command7.Usage({
     description: "Scaffold a consumer project (config, shims, barrels, app.module)",
     examples: [
-      ["Initialize with defaults", "codegen project init --yes"],
+      ["Initialize with defaults (package runtime)", "codegen project init --yes"],
+      ["Vendored runtime (legacy @shared/** model)", "codegen project init --yes --runtime vendored"],
       ["Preview without writing", "codegen project init --dry-run"],
       ["Create tsconfig if missing", "codegen project init --yes --with-tsconfig"],
       ["Overwrite existing shims", "codegen project init --force"]
@@ -13616,6 +14072,9 @@ var ProjectInitCommand = class extends Command7 {
   dryRun = Option7.Boolean("--dry-run", false);
   force = Option7.Boolean("--force", false);
   withTsconfig = Option7.Boolean("--with-tsconfig", false);
+  // Runtime mode (ADR-037). `package` (default) ⇒ depend on the npm package,
+  // vendor nothing; `vendored` ⇒ vendor src/shared/** and import via @shared/*.
+  runtime = Option7.String("--runtime", "package");
   // Vendor consumer skills into .claude/skills by default; opt out with --no-skills.
   skills = Option7.Boolean("--skills", true);
   json = Option7.Boolean("--json", false);
@@ -13627,11 +14086,18 @@ var ProjectInitCommand = class extends Command7 {
       json: this.json,
       skipDetection: false
     });
+    const runtimeMode = this.runtime === "vendored" ? "vendored" : "package";
+    if (this.runtime !== "package" && this.runtime !== "vendored" && !isJsonMode()) {
+      printWarning(
+        `--runtime '${this.runtime}' is not recognized (expected 'package' or 'vendored'); using 'package'.`
+      );
+    }
     const plan = await buildInitPlan(ctx, {
       cwd: ctx.cwd,
       force: this.force,
       withTsconfig: this.withTsconfig,
-      skipScan: false
+      skipScan: false,
+      runtimeMode
     });
     if (this.force && !isJsonMode()) {
       printWarning("--force: existing scaffold files will be overwritten.");
@@ -13775,9 +14241,9 @@ var ProjectScanCommand = class extends Command7 {
   cwd = Option7.String("--cwd", { required: false });
   async execute() {
     if (this.json) setJsonMode(true);
-    const baseCwd = this.cwd ? path28.resolve(this.cwd) : process.cwd();
-    const target = this.directory ? path28.resolve(baseCwd, this.directory) : baseCwd;
-    if (!fs17.existsSync(target)) {
+    const baseCwd = this.cwd ? path30.resolve(this.cwd) : process.cwd();
+    const target = this.directory ? path30.resolve(baseCwd, this.directory) : baseCwd;
+    if (!fs19.existsSync(target)) {
       printError(`Directory not found: ${target}`);
       return 1;
     }
@@ -13827,8 +14293,8 @@ var ProjectScanCommand = class extends Command7 {
         `architecture: ${profile.architecture.evidence.join(", ") || "\u2014"}`
       ]);
     }
-    const outPath = path28.join(target, "codegen.config.yaml");
-    const existsNow = fs17.existsSync(outPath);
+    const outPath = path30.join(target, "codegen.config.yaml");
+    const existsNow = fs19.existsSync(outPath);
     if (this.dryRun) {
       console.log("");
       printInfo("Dry run \u2014 proposed codegen.config.yaml:");
@@ -13841,7 +14307,7 @@ var ProjectScanCommand = class extends Command7 {
         printWarning(`${outPath} already exists \u2014 pass --force via edit; skipping.`);
         return 0;
       }
-      fs17.writeFileSync(outPath, yamlText);
+      fs19.writeFileSync(outPath, yamlText);
       printSuccess(`wrote ${outPath}`);
       return 0;
     }
@@ -13948,12 +14414,12 @@ var ProjectInspectCommand = class extends Command7 {
     return 2;
   }
   resolveEntitiesDir(ctx) {
-    if (this.dir) return path28.resolve(ctx.cwd, this.dir);
-    return ctx.entitiesDir ?? path28.resolve(ctx.cwd, "entities");
+    if (this.dir) return path30.resolve(ctx.cwd, this.dir);
+    return ctx.entitiesDir ?? path30.resolve(ctx.cwd, "entities");
   }
   async runAnalysis(ctx, kind) {
     const entitiesDir = this.resolveEntitiesDir(ctx);
-    if (!entitiesDir || !fs17.existsSync(entitiesDir)) {
+    if (!entitiesDir || !fs19.existsSync(entitiesDir)) {
       printError(`Directory not found: ${entitiesDir ?? "(no entities/ dir)"}`);
       return 1;
     }
@@ -13983,7 +14449,7 @@ var ProjectInspectCommand = class extends Command7 {
       out = formatConsole(filtered);
     }
     if (this.output) {
-      fs17.writeFileSync(this.output, out);
+      fs19.writeFileSync(this.output, out);
       if (!isJsonMode()) printSuccess(`wrote ${this.output}`);
     } else {
       console.log(out);
@@ -13996,7 +14462,7 @@ var ProjectInspectCommand = class extends Command7 {
   }
   async runManifest(ctx) {
     const entitiesDir = this.resolveEntitiesDir(ctx);
-    if (!entitiesDir || !fs17.existsSync(entitiesDir)) {
+    if (!entitiesDir || !fs19.existsSync(entitiesDir)) {
       printError(`Directory not found: ${entitiesDir ?? "(no entities/ dir)"}`);
       return 1;
     }
@@ -14152,17 +14618,17 @@ var ProjectGraphCommand = class extends Command7 {
       json: this.json,
       skipDetection: true
     });
-    const entitiesDir = this.dir ? path28.resolve(ctx.cwd, this.dir) : ctx.entitiesDir ?? path28.resolve(ctx.cwd, "entities");
-    if (!fs17.existsSync(entitiesDir)) {
+    const entitiesDir = this.dir ? path30.resolve(ctx.cwd, this.dir) : ctx.entitiesDir ?? path30.resolve(ctx.cwd, "entities");
+    if (!fs19.existsSync(entitiesDir)) {
       printError(`Entity directory not found: ${entitiesDir}`);
       return 1;
     }
     const relCandidates = [
-      path28.resolve(path28.dirname(entitiesDir), "relationships"),
-      path28.resolve(entitiesDir, "relationships"),
-      path28.resolve(ctx.cwd, "relationships")
+      path30.resolve(path30.dirname(entitiesDir), "relationships"),
+      path30.resolve(entitiesDir, "relationships"),
+      path30.resolve(ctx.cwd, "relationships")
     ];
-    const relationshipsDir = relCandidates.find((d) => fs17.existsSync(d));
+    const relationshipsDir = relCandidates.find((d) => fs19.existsSync(d));
     const result = await analyzeDomain(entitiesDir, relationshipsDir);
     const serialized = serializeDomainGraph(result.graph);
     if (isJsonMode()) {
@@ -14176,20 +14642,20 @@ var ProjectGraphCommand = class extends Command7 {
       return 0;
     }
     if (this.output) {
-      const outPath = path28.resolve(ctx.cwd, this.output);
-      fs17.writeFileSync(outPath, JSON.stringify(serialized, null, 2));
+      const outPath = path30.resolve(ctx.cwd, this.output);
+      fs19.writeFileSync(outPath, JSON.stringify(serialized, null, 2));
       printSuccess(`Graph written to ${outPath}`);
       printInfo(`${result.entities.length} entities, ${result.relationshipDefinitions.length} relationships, ${result.graph.edges.length} edges`);
       return 0;
     }
     const os = await import("os");
-    const tmpDir = fs17.mkdtempSync(path28.join(os.default.tmpdir(), "codegen-graph-"));
-    const graphPath = path28.join(tmpDir, "graph.json");
-    fs17.writeFileSync(graphPath, JSON.stringify(serialized, null, 2));
-    const viewerDir = path28.resolve(import.meta.dirname, "..", "..", "..", "tools", "schema-graph-viewer");
-    const viewerDist = path28.join(viewerDir, "dist", "index.html");
-    if (fs17.existsSync(viewerDist)) {
-      fs17.copyFileSync(graphPath, path28.join(viewerDir, "dist", "graph.json"));
+    const tmpDir = fs19.mkdtempSync(path30.join(os.default.tmpdir(), "codegen-graph-"));
+    const graphPath = path30.join(tmpDir, "graph.json");
+    fs19.writeFileSync(graphPath, JSON.stringify(serialized, null, 2));
+    const viewerDir = path30.resolve(import.meta.dirname, "..", "..", "..", "tools", "schema-graph-viewer");
+    const viewerDist = path30.join(viewerDir, "dist", "index.html");
+    if (fs19.existsSync(viewerDist)) {
+      fs19.copyFileSync(graphPath, path30.join(viewerDir, "dist", "graph.json"));
       printSuccess("Graph exported");
       printInfo(`${result.entities.length} entities, ${result.relationshipDefinitions.length} relationships, ${result.graph.edges.length} edges`);
       printInfo(`Graph JSON: ${graphPath}`);
@@ -14220,8 +14686,8 @@ var projectNoun = {
 var project_default = projectNoun;
 
 // src/cli/commands/dev.ts
-import fs18 from "fs";
-import path29 from "path";
+import fs20 from "fs";
+import path31 from "path";
 import { execSync as execSync3, spawn, spawnSync } from "child_process";
 import { Command as Command8, Option as Option8 } from "clipanion";
 var DEFAULT_APP_PORT = 3e3;
@@ -14254,33 +14720,33 @@ function getRedisPort(_ctx) {
   return Number(process.env.DEV_REDIS_PORT ?? DEFAULT_REDIS_PORT);
 }
 function composeFilePath(cwd) {
-  const devPath = path29.join(cwd, COMPOSE_FILE);
-  if (fs18.existsSync(devPath)) return devPath;
-  const rootPath = path29.join(cwd, "docker-compose.yml");
-  if (fs18.existsSync(rootPath)) return rootPath;
+  const devPath = path31.join(cwd, COMPOSE_FILE);
+  if (fs20.existsSync(devPath)) return devPath;
+  const rootPath = path31.join(cwd, "docker-compose.yml");
+  if (fs20.existsSync(rootPath)) return rootPath;
   return devPath;
 }
 function pidFilePath(cwd) {
-  return path29.join(cwd, PID_FILE);
+  return path31.join(cwd, PID_FILE);
 }
 function readAppPid(cwd) {
   const p = pidFilePath(cwd);
-  if (!fs18.existsSync(p)) return null;
-  const pid = parseInt(fs18.readFileSync(p, "utf-8").trim(), 10);
+  if (!fs20.existsSync(p)) return null;
+  const pid = parseInt(fs20.readFileSync(p, "utf-8").trim(), 10);
   if (isNaN(pid)) return null;
   try {
     process.kill(pid, 0);
     return pid;
   } catch {
-    fs18.rmSync(p, { force: true });
+    fs20.rmSync(p, { force: true });
     return null;
   }
 }
 function writeAppPid(cwd, pid) {
-  fs18.writeFileSync(pidFilePath(cwd), String(pid));
+  fs20.writeFileSync(pidFilePath(cwd), String(pid));
 }
 function clearAppPid(cwd) {
-  fs18.rmSync(pidFilePath(cwd), { force: true });
+  fs20.rmSync(pidFilePath(cwd), { force: true });
 }
 function checkPostgres(cwd, port) {
   const r = runCmd(`docker exec codegen-dev-postgres pg_isready -U postgres`, cwd, {
@@ -14320,9 +14786,9 @@ function checkApp(cwd, port) {
   };
 }
 function listEntityNames(ctx) {
-  if (!ctx.entitiesDir || !fs18.existsSync(ctx.entitiesDir)) return [];
+  if (!ctx.entitiesDir || !fs20.existsSync(ctx.entitiesDir)) return [];
   return findYamlFiles(ctx.entitiesDir).map(
-    (f) => path29.basename(f).replace(/\.ya?ml$/, "")
+    (f) => path31.basename(f).replace(/\.ya?ml$/, "")
   );
 }
 function formatServiceLine(svc) {
@@ -14332,8 +14798,8 @@ function formatServiceLine(svc) {
   return `${icon} ${svc.name.padEnd(12)}  ${theme.muted(`${svc.host}:${svc.port}`)}    ${status}${pidStr}`;
 }
 function ensureComposeFile(cwd, pgPort, redisPort) {
-  const composePath = path29.join(cwd, COMPOSE_FILE);
-  if (fs18.existsSync(composePath)) return composePath;
+  const composePath = path31.join(cwd, COMPOSE_FILE);
+  if (fs20.existsSync(composePath)) return composePath;
   const content = `# Auto-generated by codegen dev
 # Ports offset from defaults to avoid conflicts with other local services.
 services:
@@ -14368,7 +14834,7 @@ services:
 volumes:
   codegen-dev-pgdata:
 `;
-  fs18.writeFileSync(composePath, content);
+  fs20.writeFileSync(composePath, content);
   return composePath;
 }
 var DevUpCommand = class extends Command8 {
@@ -14417,7 +14883,7 @@ var DevUpCommand = class extends Command8 {
     if (!pgReady) printWarning("postgres did not become healthy in time");
     if (!redisReady) printWarning("redis did not become healthy in time");
     const drizzleConfig = ["drizzle.config.ts", "drizzle.config.js"].find(
-      (f) => fs18.existsSync(path29.join(ctx.cwd, f))
+      (f) => fs20.existsSync(path31.join(ctx.cwd, f))
     );
     if (drizzleConfig) {
       if (!isJsonMode()) printInfo("pushing database schema...");
@@ -14437,8 +14903,8 @@ var DevUpCommand = class extends Command8 {
         if (!isJsonMode()) printInfo("starting NestJS app...");
         const dbUrl = `postgres://postgres:postgres@localhost:${pgPort}/codegen_dev`;
         const redisUrl = `redis://localhost:${redisPort}`;
-        const logFile = path29.join(ctx.cwd, ".dev-app.log");
-        const logFd = fs18.openSync(logFile, "a");
+        const logFile = path31.join(ctx.cwd, ".dev-app.log");
+        const logFd = fs20.openSync(logFile, "a");
         const child = spawn("bun", ["src/main.ts"], {
           cwd: ctx.cwd,
           detached: true,
@@ -14451,7 +14917,7 @@ var DevUpCommand = class extends Command8 {
           }
         });
         child.unref();
-        fs18.closeSync(logFd);
+        fs20.closeSync(logFd);
         if (child.pid) {
           writeAppPid(ctx.cwd, child.pid);
           spawnSync("sleep", ["2"]);
@@ -14595,8 +15061,8 @@ var DevLogsCommand = class extends Command8 {
       }
       return 0;
     }
-    const logFile = path29.join(ctx.cwd, ".dev-app.log");
-    if (!fs18.existsSync(logFile)) {
+    const logFile = path31.join(ctx.cwd, ".dev-app.log");
+    if (!fs20.existsSync(logFile)) {
       printInfo("no app logs found \u2014 is the app running?");
       return 0;
     }
@@ -14639,8 +15105,8 @@ var DevRestartCommand = class extends Command8 {
     spawnSync("sleep", ["1"]);
     const dbUrl = `postgres://postgres:postgres@localhost:${pgPort}/codegen_dev`;
     const redisUrl = `redis://localhost:${redisPort}`;
-    const logFile = path29.join(ctx.cwd, ".dev-app.log");
-    const logFd = fs18.openSync(logFile, "a");
+    const logFile = path31.join(ctx.cwd, ".dev-app.log");
+    const logFd = fs20.openSync(logFile, "a");
     const child = spawn("bun", ["src/main.ts"], {
       cwd: ctx.cwd,
       detached: true,
@@ -14653,7 +15119,7 @@ var DevRestartCommand = class extends Command8 {
       }
     });
     child.unref();
-    fs18.closeSync(logFd);
+    fs20.closeSync(logFd);
     if (child.pid) {
       writeAppPid(ctx.cwd, child.pid);
       spawnSync("sleep", ["2"]);
@@ -14768,11 +15234,11 @@ var devNoun = {
 var dev_default = devNoun;
 
 // src/cli/commands/relationship.ts
-import fs19 from "fs";
-import path30 from "path";
+import fs21 from "fs";
+import path32 from "path";
 import { Command as Command9, Option as Option9 } from "clipanion";
 function listRelationshipYamls2(dir) {
-  if (!fs19.existsSync(dir)) return [];
+  if (!fs21.existsSync(dir)) return [];
   return findYamlFiles(dir).filter(
     (full) => detectYamlType(full) === "relationship"
   );
@@ -14796,7 +15262,7 @@ function padRight2(s, n) {
   return s.length >= n ? s : s + " ".repeat(n - s.length);
 }
 async function summary6(ctx) {
-  const relDir = path30.resolve(ctx.cwd, "relationships");
+  const relDir = path32.resolve(ctx.cwd, "relationships");
   const files = listRelationshipYamls2(relDir);
   if (files.length === 0) {
     return {
@@ -14866,14 +15332,14 @@ var RelationshipNewCommand = class extends Command9 {
     }
     let targets = [];
     if (this.all) {
-      const dir = path30.resolve(ctx.cwd, "relationships");
+      const dir = path32.resolve(ctx.cwd, "relationships");
       targets = listRelationshipYamls2(dir);
       if (targets.length === 0) {
         printError(`No relationship YAML files found in ${dir}`);
         return 1;
       }
     } else if (this.yaml) {
-      targets = [path30.resolve(ctx.cwd, this.yaml)];
+      targets = [path32.resolve(ctx.cwd, this.yaml)];
     } else {
       printError("Missing YAML path. Pass a file or --all.");
       return 2;
@@ -14890,7 +15356,7 @@ var RelationshipNewCommand = class extends Command9 {
     }
     if (invalid.length > 0) {
       for (const i of invalid) {
-        printError(`${path30.basename(i.file)} \u2014 ${i.message}`);
+        printError(`${path32.basename(i.file)} \u2014 ${i.message}`);
       }
       if (!isJsonMode()) return 1;
     }
@@ -14921,7 +15387,7 @@ var RelationshipNewCommand = class extends Command9 {
     }
     const succeeded = [];
     const failed = [
-      ...invalid.map((i) => ({ name: path30.basename(i.file), file: i.file, message: i.message }))
+      ...invalid.map((i) => ({ name: path32.basename(i.file), file: i.file, message: i.message }))
     ];
     for (const v of validated) {
       if (!isJsonMode()) {
@@ -14940,8 +15406,8 @@ var RelationshipNewCommand = class extends Command9 {
         if (!isJsonMode()) printError(`${v.name} \u2014 ${res.stderr ?? "failed"}`);
       }
     }
-    const entitiesDir = ctx.entitiesDir ?? path30.resolve(ctx.cwd, "entities");
-    const relationshipsDir = path30.resolve(ctx.cwd, "relationships");
+    const entitiesDir = ctx.entitiesDir ?? path32.resolve(ctx.cwd, "entities");
+    const relationshipsDir = path32.resolve(ctx.cwd, "relationships");
     const generatedDir = resolveGeneratedDir(ctx);
     const architecture = resolveArchitecture(ctx);
     let barrelResult = null;
@@ -14986,7 +15452,7 @@ var RelationshipNewCommand = class extends Command9 {
       }
       if (barrelResult) {
         printInfo(
-          `barrels regenerated (${barrelResult.entityCount} modules) \u2192 ${path30.relative(ctx.cwd, barrelResult.modulesBarrel)}, ${path30.relative(ctx.cwd, barrelResult.schemaBarrel)}`
+          `barrels regenerated (${barrelResult.entityCount} modules) \u2192 ${path32.relative(ctx.cwd, barrelResult.modulesBarrel)}, ${path32.relative(ctx.cwd, barrelResult.schemaBarrel)}`
         );
       }
     }
@@ -15009,7 +15475,7 @@ var RelationshipListCommand = class extends Command9 {
       json: this.json,
       skipDetection: true
     });
-    const relDir = path30.resolve(ctx.cwd, "relationships");
+    const relDir = path32.resolve(ctx.cwd, "relationships");
     const files = listRelationshipYamls2(relDir);
     if (files.length === 0) {
       printInfo("No relationship definitions found.");
@@ -15049,7 +15515,7 @@ var relationshipNoun = {
 var relationship_default = relationshipNoun;
 
 // src/cli/commands/junction.ts
-import path31 from "path";
+import path33 from "path";
 import { Command as Command10, Option as Option10 } from "clipanion";
 function summarizeJunctionFile(filePath) {
   const result = loadJunctionFromYaml(filePath);
@@ -15072,7 +15538,7 @@ function padRight3(s, n) {
   return s.length >= n ? s : s + " ".repeat(n - s.length);
 }
 async function summary7(ctx) {
-  const junctionDir = path31.resolve(ctx.cwd, "junctions");
+  const junctionDir = path33.resolve(ctx.cwd, "junctions");
   const files = listJunctionYamls(junctionDir);
   if (files.length === 0) {
     return {
@@ -15142,14 +15608,14 @@ var JunctionNewCommand = class extends Command10 {
     }
     let targets = [];
     if (this.all) {
-      const dir = path31.resolve(ctx.cwd, "junctions");
+      const dir = path33.resolve(ctx.cwd, "junctions");
       targets = listJunctionYamls(dir);
       if (targets.length === 0) {
         printError(`No junction YAML files found in ${dir}`);
         return 1;
       }
     } else if (this.yaml) {
-      targets = [path31.resolve(ctx.cwd, this.yaml)];
+      targets = [path33.resolve(ctx.cwd, this.yaml)];
     } else {
       printError("Missing YAML path. Pass a file or --all.");
       return 2;
@@ -15168,7 +15634,7 @@ var JunctionNewCommand = class extends Command10 {
     }
     if (invalid.length > 0) {
       for (const i of invalid) {
-        printError(`${path31.basename(i.file)} \u2014 ${i.message}`);
+        printError(`${path33.basename(i.file)} \u2014 ${i.message}`);
       }
       if (!isJsonMode()) return 1;
     }
@@ -15199,7 +15665,7 @@ var JunctionNewCommand = class extends Command10 {
     }
     const succeeded = [];
     const failed = [
-      ...invalid.map((i) => ({ name: path31.basename(i.file), file: i.file, message: i.message }))
+      ...invalid.map((i) => ({ name: path33.basename(i.file), file: i.file, message: i.message }))
     ];
     for (const v of validated) {
       if (!isJsonMode()) {
@@ -15218,9 +15684,9 @@ var JunctionNewCommand = class extends Command10 {
         if (!isJsonMode()) printError(`${v.name} \u2014 ${res.stderr ?? "failed"}`);
       }
     }
-    const entitiesDir = ctx.entitiesDir ?? path31.resolve(ctx.cwd, "entities");
-    const relationshipsDir = path31.resolve(ctx.cwd, "relationships");
-    const junctionsDir = path31.resolve(ctx.cwd, "junctions");
+    const entitiesDir = ctx.entitiesDir ?? path33.resolve(ctx.cwd, "entities");
+    const relationshipsDir = path33.resolve(ctx.cwd, "relationships");
+    const junctionsDir = path33.resolve(ctx.cwd, "junctions");
     const generatedDir = resolveGeneratedDir(ctx);
     const architecture = resolveArchitecture(ctx);
     let barrelResult = null;
@@ -15266,7 +15732,7 @@ var JunctionNewCommand = class extends Command10 {
       }
       if (barrelResult) {
         printInfo(
-          `barrels regenerated (${barrelResult.entityCount} modules) \u2192 ${path31.relative(ctx.cwd, barrelResult.modulesBarrel)}, ${path31.relative(ctx.cwd, barrelResult.schemaBarrel)}`
+          `barrels regenerated (${barrelResult.entityCount} modules) \u2192 ${path33.relative(ctx.cwd, barrelResult.modulesBarrel)}, ${path33.relative(ctx.cwd, barrelResult.schemaBarrel)}`
         );
       }
     }
@@ -15289,7 +15755,7 @@ var JunctionListCommand = class extends Command10 {
       json: this.json,
       skipDetection: true
     });
-    const junctionDir = path31.resolve(ctx.cwd, "junctions");
+    const junctionDir = path33.resolve(ctx.cwd, "junctions");
     const files = listJunctionYamls(junctionDir);
     if (files.length === 0) {
       printInfo("No junction definitions found.");
@@ -15329,8 +15795,8 @@ var junctionNoun = {
 var junction_default = junctionNoun;
 
 // src/cli/commands/events.ts
-import fs20 from "fs";
-import path32 from "path";
+import fs22 from "fs";
+import path34 from "path";
 import ts3 from "typescript";
 import { Command as Command11, Option as Option11 } from "clipanion";
 function scanSourceFileForConsumers(sourceFile, filePath, eventType) {
@@ -15429,7 +15895,7 @@ function scanDirectoryForConsumers(rootDir, eventType) {
   const tier1 = [];
   let hasEventFlowImport = false;
   for (const filePath of files) {
-    const text2 = fs20.readFileSync(filePath, "utf8");
+    const text2 = fs22.readFileSync(filePath, "utf8");
     const sourceFile = ts3.createSourceFile(
       filePath,
       text2,
@@ -15466,7 +15932,7 @@ function suggestEventTypes(target, known, limit = 3) {
   return known.map((t) => ({ t, d: levenshtein(target, t) })).sort((a, b) => a.d - b.d).slice(0, limit).map((x) => x.t);
 }
 function renderConsumerReport(result, cwd) {
-  const rel2 = (p) => path32.relative(cwd, p) || p;
+  const rel2 = (p) => path34.relative(cwd, p) || p;
   const lines = [];
   const total = result.tier3.length + result.tier2.length + result.tier1.length;
   lines.push(`Event: ${result.eventType}`);
@@ -15502,7 +15968,7 @@ function renderConsumerReport(result, cwd) {
   return lines;
 }
 function runConsumersScan(opts) {
-  const scanRoot = opts.scanRoot ?? path32.join(opts.cwd, "src");
+  const scanRoot = opts.scanRoot ?? path34.join(opts.cwd, "src");
   const handlersDir = opts.handlersDir ?? scanRoot;
   const allTriggers = scanHandlerFiles(handlersDir);
   const tier3 = allTriggers.filter((t) => t.event === opts.eventType).map((t) => ({
@@ -15511,8 +15977,8 @@ function runConsumersScan(opts) {
     sourceFile: t.sourceFile,
     sourceLine: t.sourceLine
   }));
-  const tier21 = fs20.existsSync(scanRoot) ? scanDirectoryForConsumers(scanRoot, opts.eventType) : { tier2: [], tier1: [], hasEventFlowImport: false };
-  const eventsGeneratedDir = opts.eventsGeneratedDir ?? path32.join(
+  const tier21 = fs22.existsSync(scanRoot) ? scanDirectoryForConsumers(scanRoot, opts.eventType) : { tier2: [], tier1: [], hasEventFlowImport: false };
+  const eventsGeneratedDir = opts.eventsGeneratedDir ?? path34.join(
     resolveSubsystemsRootFromContext(opts.cwd, opts.config),
     "events",
     "generated"
@@ -15533,11 +15999,11 @@ function runConsumersScan(opts) {
 function resolveSubsystemsRootFromContext(cwd, config) {
   const configured = config?.paths?.subsystems;
   if (typeof configured === "string" && configured.length > 0) {
-    return path32.resolve(cwd, configured);
+    return path34.resolve(cwd, configured);
   }
   const backendSrc = config?.paths?.backend_src;
   const base = typeof backendSrc === "string" && backendSrc.length > 0 ? backendSrc : "src";
-  return path32.resolve(cwd, base, "shared", "subsystems");
+  return path34.resolve(cwd, base, "shared", "subsystems");
 }
 var EventsConsumersCommand = class extends Command11 {
   static paths = [["events", "consumers"]];
@@ -15626,7 +16092,7 @@ var eventsNoun = {
 var events_default = eventsNoun;
 
 // src/cli/commands/orchestration.ts
-import path33 from "path";
+import path35 from "path";
 import { Command as Command12, Option as Option12 } from "clipanion";
 var DEFAULT_PATTERN_GLOBS = ["src/patterns/*.pattern.ts"];
 function resolvePatternGlobs(ctx) {
@@ -15640,10 +16106,10 @@ function resolveOrchestrationOutputRoot(ctx) {
   const paths = ctx.config?.paths;
   const explicit = paths?.orchestration_src;
   if (typeof explicit === "string" && explicit.length > 0) {
-    return path33.resolve(ctx.cwd, explicit);
+    return path35.resolve(ctx.cwd, explicit);
   }
   const backendSrc = typeof paths?.backend_src === "string" && paths.backend_src.length > 0 ? paths.backend_src : "app/backend/src";
-  return path33.resolve(ctx.cwd, backendSrc, "orchestration");
+  return path35.resolve(ctx.cwd, backendSrc, "orchestration");
 }
 async function reloadRegistry(ctx) {
   _resetRegistryForTests({ includeLibrary: false });
@@ -15732,12 +16198,12 @@ var OrchestrationGenCommand = class extends Command12 {
         );
         for (const f of result.files) {
           console.log(
-            `  ${theme.muted(icons.arrow)} ${path33.relative(ctx.cwd, f.outputPath)}`
+            `  ${theme.muted(icons.arrow)} ${path35.relative(ctx.cwd, f.outputPath)}`
           );
         }
       } else {
         printSuccess(
-          `Emitted ${result.files.length} file(s) across ${targets.length} pattern(s) \u2192 ${path33.relative(ctx.cwd, outputRoot)}`
+          `Emitted ${result.files.length} file(s) across ${targets.length} pattern(s) \u2192 ${path35.relative(ctx.cwd, outputRoot)}`
         );
       }
       return 0;