@runa-ai/runa-cli 0.6.0 → 0.7.0

package/dist/cli/contract-output.d.ts

@@ -1,4 +1,5 @@
 import type { Command } from 'commander';
 export declare function markJsonEmitted(): void;
+export declare function writeJsonEnvelope(payload: string): void;
 export declare function emitDefaultSuccessIfNeeded(cmd: Command): void;
 //# sourceMappingURL=contract-output.d.ts.map

package/dist/{cli-GFRZCJQR.js → cli-2JNBJUBB.js}

@@ -2,9 +2,8 @@
 import { createRequire } from 'module';
 import { enableNonInteractiveMode } from './chunk-6Y3LAUGL.js';
 import { getRequestedCommandNameFromArgv } from './chunk-UWWSAPDR.js';
-import { CLI_VERSION, HAS_ADMIN_COMMAND } from './chunk-GOGRLQNP.js';
-import { emitDefaultSuccessIfNeeded } from './chunk-RRGQCUKT.js';
-import './chunk-JT5SUTWE.js';
+import { CLI_VERSION, HAS_ADMIN_COMMAND } from './chunk-AIP6MR42.js';
+import { emitDefaultSuccessIfNeeded } from './chunk-WJXC4MVY.js';
 import { parseOutputFormat, setOutputFormat, getOutputFormatFromEnv } from './chunk-HKUWEGUX.js';
 import { init_esm_shims } from './chunk-VRXHCR5K.js';
 import { CLIError } from '@runa-ai/runa/cli-runtime';
@@ -116,6 +115,14 @@ function applyEarlyGlobalFlags(argv) {
 }
 
 // src/cli/index.ts
+function pickCommands(commands) {
+  return commands.filter((command) => {
+    if (!(command instanceof Command)) {
+      return false;
+    }
+    return true;
+  });
+}
 function normalizeRequestedCommandName(value) {
   if (!value) return null;
   const trimmed = value.trim();
@@ -138,7 +145,7 @@ function isTestCommand(requested) {
 async function registerProjectLifecycleCommands(program, requested, loadAllCommands) {
   if (!loadAllCommands && requested) {
     if (requested === "init") {
-      const { initCommand: initCommand2 } = await import('./init-ELK5QCWR.js');
+      const { initCommand: initCommand2 } = await import('./init-ZIL6LRFO.js');
       program.addCommand(initCommand2);
       return;
     }
@@ -148,22 +155,22 @@ async function registerProjectLifecycleCommands(program, requested, loadAllComma
       return;
     }
     if (requested === "upgrade") {
-      const { upgradeCommand: upgradeCommand2 } = await import('./upgrade-3SLWVNAC.js');
+      const { upgradeCommand: upgradeCommand2 } = await import('./upgrade-NUK3ZBCL.js');
       program.addCommand(upgradeCommand2);
       return;
     }
     if (requested === "validate") {
-      const { validateCommand: validateCommand2 } = await import('./validate-SM4PXPS7.js');
+      const { validateCommand: validateCommand2 } = await import('./validate-CAAW4Y44.js');
       program.addCommand(validateCommand2);
       return;
     }
     if (requested === "build") {
-      const { buildCommand: buildCommand2 } = await import('./build-BXUJKYHC.js');
+      const { buildCommand: buildCommand2 } = await import('./build-V66FAQXB.js');
       program.addCommand(buildCommand2);
       return;
     }
     if (requested === "dev") {
-      const { devCommand: devCommand2 } = await import('./dev-A7RW6XQV.js');
+      const { devCommand: devCommand2 } = await import('./dev-5YXNPTCJ.js');
       program.addCommand(devCommand2);
       return;
     }
@@ -176,12 +183,12 @@ async function registerProjectLifecycleCommands(program, requested, loadAllComma
     { buildCommand },
     { devCommand }
   ] = await Promise.all([
-    import('./init-ELK5QCWR.js'),
+    import('./init-ZIL6LRFO.js'),
     import('./prepare-32DOVHTE.js'),
-    import('./upgrade-3SLWVNAC.js'),
-    import('./validate-SM4PXPS7.js'),
-    import('./build-BXUJKYHC.js'),
-    import('./dev-A7RW6XQV.js')
+    import('./upgrade-NUK3ZBCL.js'),
+    import('./validate-CAAW4Y44.js'),
+    import('./build-V66FAQXB.js'),
+    import('./dev-5YXNPTCJ.js')
   ]);
   program.addCommand(initCommand);
   program.addCommand(prepareCommand);
@@ -199,132 +206,111 @@ var TEST_GENERATION_COMMANDS = /* @__PURE__ */ new Set([
   "test:security:generate",
   "test:unit:generate"
 ]);
-async function registerTestCommands(program, requested, loadAllCommands) {
-  if (!loadAllCommands && requested) {
-    if (requested === "manifest") {
-      const { manifestCommand: manifestCommand2 } = await import('./manifest-2NOQ2IMK.js');
-      program.addCommand(manifestCommand2);
-      return;
-    }
-    if (requested === "inject-test-attrs") {
-      const { injectTestAttrsCommand: injectTestAttrsCommand2 } = await import('./inject-test-attrs-Y5UD5P7Q.js');
-      program.addCommand(injectTestAttrsCommand2);
-      return;
-    }
-    if (TEST_GENERATION_COMMANDS.has(requested)) {
-      const testGenModule2 = await import('./test-gen-QPWOIEHU.js');
-      const {
-        dbTestUpdateGoldenCommand: dbTestUpdateGoldenCommand2,
-        testApiGenerateCommand: testApiGenerateCommand2,
-        testComponentGenerateCommand: testComponentGenerateCommand2,
-        testE2EGenerateCommand: testE2EGenerateCommand2,
-        testE2EScaffoldCommand: testE2EScaffoldCommand2,
-        testSecurityGenerateCommand: testSecurityGenerateCommand2,
-        testUnitGenerateCommand: testUnitGenerateCommand2
-      } = testGenModule2;
-      if (requested === "db:test:update-golden") {
-        program.addCommand(dbTestUpdateGoldenCommand2);
-      }
-      if (requested === "test:api:gen") {
-        program.addCommand(testApiGenerateCommand2);
-      }
-      if (requested === "test:component:gen") {
-        program.addCommand(testComponentGenerateCommand2);
-      }
-      if (requested === "test:e2e:generate") {
-        program.addCommand(testE2EGenerateCommand2);
-      }
-      if (requested === "test:e2e:scaffold") {
-        program.addCommand(testE2EScaffoldCommand2);
-      }
-      if (requested === "test:security:generate") {
-        program.addCommand(testSecurityGenerateCommand2);
-      }
-      if (requested === "test:unit:generate") {
-        program.addCommand(testUnitGenerateCommand2);
-      }
-      return;
-    }
-    if (requested === "test" || requested.startsWith("test:")) {
-      const testModule2 = await import('./test-QYXE5UVW.js');
-      const {
-        testApiCommand: testApiCommand2,
-        testBrowserCommand: testBrowserCommand2,
-        // Legacy commands (backward compat)
-        testCommand: testCommand2,
-        testDbCommand: testDbCommand2,
-        testE2ECommand: testE2ECommand2,
-        // New naming scheme (2025-01)
-        testFastCommand: testFastCommand2,
-        testIntegrationCommand: testIntegrationCommand2,
-        // Canonical layer commands
-        testLayer0Command: testLayer0Command2,
-        testLayer1Command: testLayer1Command2,
-        testLayer2Command: testLayer2Command2,
-        testLayer3Command: testLayer3Command2,
-        testLayer4Command: testLayer4Command2,
-        // Note: Layer 5 Flow E2E was merged into Layer 1 XState Unit Tests
-        testLintCommand: testLintCommand2,
-        testLogicCommand: testLogicCommand2,
-        testOWASPGenerateCommand: testOWASPGenerateCommand2,
-        testSchemaCommand: testSchemaCommand2,
-        testServiceCommand: testServiceCommand2,
-        testStaticCommand: testStaticCommand2
-      } = testModule2;
-      const candidates = [
-        testCommand2,
-        testDbCommand2,
-        testE2ECommand2,
-        testFastCommand2,
-        testLintCommand2,
-        testLogicCommand2,
-        testSchemaCommand2,
-        testApiCommand2,
-        testBrowserCommand2,
-        testLayer0Command2,
-        testLayer1Command2,
-        testLayer2Command2,
-        testLayer3Command2,
-        testLayer4Command2,
-        testStaticCommand2,
-        testServiceCommand2,
-        testIntegrationCommand2,
-        testOWASPGenerateCommand2
-      ];
-      const requestedCommand = candidates.find((cmd) => cmd.name() === requested);
-      if (requestedCommand) {
-        program.addCommand(requestedCommand);
-      } else {
-        for (const cmd of candidates) {
-          program.addCommand(cmd);
-        }
-      }
-      return;
-    }
+async function addSingleTestCommand(program, requested) {
+  if (requested === "manifest") {
+    const { manifestCommand } = await import('./manifest-TMFLESHW.js');
+    program.addCommand(manifestCommand);
+    return true;
   }
-  const [testModule, testGenModule, { injectTestAttrsCommand }, { manifestCommand }] = await Promise.all([
-    import('./test-QYXE5UVW.js'),
-    import('./test-gen-QPWOIEHU.js'),
-    import('./inject-test-attrs-Y5UD5P7Q.js'),
-    import('./manifest-2NOQ2IMK.js')
-  ]);
+  if (requested === "inject-test-attrs") {
+    const { injectTestAttrsCommand } = await import('./inject-test-attrs-P44BVTQS.js');
+    program.addCommand(injectTestAttrsCommand);
+    return true;
+  }
+  if (!TEST_GENERATION_COMMANDS.has(requested)) return false;
+  const testGenModule = await import('./test-gen-FS4CEY3P.js');
+  const commandMap = {
+    "db:test:update-golden": testGenModule.dbTestUpdateGoldenCommand,
+    "test:api:gen": testGenModule.testApiGenerateCommand,
+    "test:component:gen": testGenModule.testComponentGenerateCommand,
+    "test:e2e:generate": testGenModule.testE2EGenerateCommand,
+    "test:e2e:scaffold": testGenModule.testE2EScaffoldCommand,
+    "test:security:generate": testGenModule.testSecurityGenerateCommand,
+    "test:unit:generate": testGenModule.testUnitGenerateCommand
+  };
+  const command = commandMap[requested];
+  if (!command) return false;
+  program.addCommand(command);
+  return true;
+}
+async function registerFocusedTestCommand(program, requested) {
+  const testModule = await import('./test-V4KQL574.js');
   const {
+    testCommand,
+    testDbCommand,
+    testE2ECommand,
     testApiCommand,
     testBrowserCommand,
-    // Legacy commands (backward compat)
+    testFastCommand,
+    testIntegrationCommand,
+    testLayer0Command,
+    testLayer1Command,
+    testLayer2Command,
+    testLayer3Command,
+    testLayer4Command,
+    // Note: Layer 5 Flow E2E was merged into Layer 1 XState Unit Tests
+    testLintCommand,
+    testLogicCommand,
+    testOWASPGenerateCommand,
+    testSchemaCommand,
+    testServiceCommand,
+    testStaticCommand
+  } = testModule;
+  const candidates = pickCommands([
     testCommand,
     testDbCommand,
     testE2ECommand,
-    // New naming scheme (2025-01)
+    testFastCommand,
+    testLintCommand,
+    testLogicCommand,
+    testSchemaCommand,
+    testApiCommand,
+    testBrowserCommand,
+    testLayer0Command,
+    testLayer1Command,
+    testLayer2Command,
+    testLayer3Command,
+    testLayer4Command,
+    testStaticCommand,
+    testServiceCommand,
+    testIntegrationCommand,
+    testOWASPGenerateCommand
+  ]);
+  const matched = candidates.find((command) => command.name() === requested);
+  if (matched) {
+    program.addCommand(matched);
+    return true;
+  }
+  if (!requested.startsWith("test:") && requested !== "test") {
+    return false;
+  }
+  for (const command of candidates) {
+    program.addCommand(command);
+  }
+  return true;
+}
+async function registerAllTestCommands(program) {
+  const [testModule, testGenModule, injectModule, manifestModule] = await Promise.all([
+    import('./test-V4KQL574.js'),
+    import('./test-gen-FS4CEY3P.js'),
+    import('./inject-test-attrs-P44BVTQS.js'),
+    import('./manifest-TMFLESHW.js')
+  ]);
+  const { injectTestAttrsCommand } = injectModule;
+  const { manifestCommand } = manifestModule;
+  const {
+    testCommand,
+    testApiCommand,
+    testBrowserCommand,
+    testDbCommand,
+    testE2ECommand,
     testFastCommand,
     testIntegrationCommand,
-    // Canonical layer commands
     testLayer0Command,
     testLayer1Command,
     testLayer2Command,
     testLayer3Command,
     testLayer4Command,
-    // Note: Layer 5 Flow E2E was merged into Layer 1 XState Unit Tests
     testLintCommand,
     testLogicCommand,
     testOWASPGenerateCommand,
@@ -341,58 +327,94 @@ async function registerTestCommands(program, requested, loadAllCommands) {
     testSecurityGenerateCommand,
     testUnitGenerateCommand
   } = testGenModule;
-  program.addCommand(testFastCommand);
-  program.addCommand(testDbCommand);
-  program.addCommand(testE2ECommand);
-  program.addCommand(testLintCommand);
-  program.addCommand(testLogicCommand);
-  program.addCommand(testSchemaCommand);
-  program.addCommand(testApiCommand);
-  program.addCommand(testBrowserCommand);
-  program.addCommand(testLayer0Command);
-  program.addCommand(testLayer1Command);
-  program.addCommand(testLayer2Command);
-  program.addCommand(testLayer3Command);
-  program.addCommand(testLayer4Command);
-  program.addCommand(testStaticCommand);
-  program.addCommand(testServiceCommand);
-  program.addCommand(testIntegrationCommand);
-  program.addCommand(testUnitGenerateCommand);
-  program.addCommand(testE2EGenerateCommand);
-  program.addCommand(testSecurityGenerateCommand);
-  program.addCommand(testOWASPGenerateCommand);
-  program.addCommand(testApiGenerateCommand);
-  program.addCommand(testComponentGenerateCommand);
-  program.addCommand(dbTestUpdateGoldenCommand);
-  program.addCommand(testCommand);
-  program.addCommand(testE2EScaffoldCommand);
-  program.addCommand(injectTestAttrsCommand);
-  program.addCommand(manifestCommand);
+  const allCommands = pickCommands([
+    testFastCommand,
+    testDbCommand,
+    testE2ECommand,
+    testLintCommand,
+    testLogicCommand,
+    testSchemaCommand,
+    testApiCommand,
+    testBrowserCommand,
+    testLayer0Command,
+    testLayer1Command,
+    testLayer2Command,
+    testLayer3Command,
+    testLayer4Command,
+    testStaticCommand,
+    testServiceCommand,
+    testIntegrationCommand,
+    testUnitGenerateCommand,
+    testE2EGenerateCommand,
+    testSecurityGenerateCommand,
+    testOWASPGenerateCommand,
+    testApiGenerateCommand,
+    testComponentGenerateCommand,
+    dbTestUpdateGoldenCommand,
+    testE2EScaffoldCommand,
+    testCommand,
+    injectTestAttrsCommand,
+    manifestCommand
+  ]);
+  for (const command of allCommands) {
+    program.addCommand(command);
+  }
+}
+async function registerTestCommands(program, requested, loadAllCommands) {
+  if (!loadAllCommands && requested) {
+    const addedSingle = await addSingleTestCommand(program, requested);
+    if (addedSingle) {
+      return;
+    }
+    if (requested === "test" || requested.startsWith("test:")) {
+      const addedFocused = await registerFocusedTestCommand(program, requested);
+      if (addedFocused) {
+        return;
+      }
+      return;
+    }
+    return;
+  }
+  if (loadAllCommands) {
+    await registerAllTestCommands(program);
+    return;
+  }
+  if (!requested || isTestCommand(requested)) {
+    const commandToLoad = requested ?? "test";
+    await registerFocusedTestCommand(program, commandToLoad);
+    return;
+  }
+  await registerAllTestCommands(program);
 }
 async function registerStatusCheckAndUtilityCommands(program, requested, loadAllCommands) {
   if (!loadAllCommands && requested) {
     if (requested === "status") {
-      const { statusCommand: statusCommand2 } = await import('./status-IJ4ZWHMX.js');
+      const { statusCommand: statusCommand2 } = await import('./status-UTKS63AB.js');
       program.addCommand(statusCommand2);
       return;
     }
     if (requested === "check") {
-      const { checkCommand: checkCommand2 } = await import('./check-6AB5NGWK.js');
+      const { checkCommand: checkCommand2 } = await import('./check-LOMVIRHX.js');
       program.addCommand(checkCommand2.name("check"));
       return;
     }
+    if (requested === "doctor") {
+      const { doctorCommand: doctorCommand2 } = await import('./doctor-MZLOA53G.js');
+      program.addCommand(doctorCommand2);
+      return;
+    }
     if (requested === "cache") {
-      const { cacheCommand: cacheCommand2 } = await import('./cache-H63JKFYH.js');
+      const { cacheCommand: cacheCommand2 } = await import('./cache-N7WNPEYF.js');
       program.addCommand(cacheCommand2);
       return;
     }
     if (requested === "telemetry") {
-      const { telemetryCommand: telemetryCommand2 } = await import('./telemetry-FN7V727Y.js');
+      const { telemetryCommand: telemetryCommand2 } = await import('./telemetry-P56UBLZ2.js');
       program.addCommand(telemetryCommand2);
       return;
     }
     if (requested === "link" || requested === "unlink") {
-      const { linkCommand: linkCommand2, unlinkCommand: unlinkCommand2 } = await import('./link-C43JRZWY.js');
+      const { linkCommand: linkCommand2, unlinkCommand: unlinkCommand2 } = await import('./link-VSNDVZZD.js');
       program.addCommand(linkCommand2);
       program.addCommand(unlinkCommand2);
       return;
@@ -401,29 +423,32 @@ async function registerStatusCheckAndUtilityCommands(program, requested, loadAll
   const [
     { statusCommand },
     { checkCommand },
+    { doctorCommand },
     { cacheCommand },
     { telemetryCommand },
     { linkCommand, unlinkCommand }
   ] = await Promise.all([
-    import('./status-IJ4ZWHMX.js'),
-    import('./check-6AB5NGWK.js'),
-    import('./cache-H63JKFYH.js'),
-    import('./telemetry-FN7V727Y.js'),
-    import('./link-C43JRZWY.js')
+    import('./status-UTKS63AB.js'),
+    import('./check-LOMVIRHX.js'),
+    import('./doctor-MZLOA53G.js'),
+    import('./cache-N7WNPEYF.js'),
+    import('./telemetry-P56UBLZ2.js'),
+    import('./link-VSNDVZZD.js')
   ]);
   program.addCommand(statusCommand);
   program.addCommand(checkCommand.name("check"));
+  program.addCommand(doctorCommand);
   program.addCommand(cacheCommand);
   program.addCommand(telemetryCommand);
   program.addCommand(linkCommand);
   program.addCommand(unlinkCommand);
 }
 async function registerCiCommand(program) {
-  const { ciCommand } = await import('./ci-V3PIG2GI.js');
+  const { ciCommand } = await import('./ci-ZWRVWNFX.js');
   program.addCommand(ciCommand);
 }
 async function registerDbCommand(program) {
-  const { dbCommand } = await import('./db-HR7CREX2.js');
+  const { dbCommand } = await import('./db-XULCILOU.js');
   program.addCommand(dbCommand);
 }
 async function registerServicesCommand(program) {
@@ -431,11 +456,11 @@ async function registerServicesCommand(program) {
   program.addCommand(servicesCommand);
 }
 async function registerEnvCommand(program) {
-  const { envCommand } = await import('./env-B47Z4747.js');
+  const { envCommand } = await import('./env-SS66PZ4B.js');
   program.addCommand(envCommand);
 }
 async function registerHotfixCommand(program) {
-  const { hotfixCommand } = await import('./hotfix-CULKKMGS.js');
+  const { hotfixCommand } = await import('./hotfix-YA3DGLOM.js');
   program.addCommand(hotfixCommand);
 }
 async function registerSdkCommand(program) {
@@ -447,19 +472,19 @@ async function registerUiCommand(program) {
   program.addCommand(uiCommand);
 }
 async function registerWatchCommand(program) {
-  const { watchCommand } = await import('./watch-UCDVOQAH.js');
+  const { watchCommand } = await import('./watch-PNTKZYFB.js');
   program.addCommand(watchCommand);
 }
 async function registerWorkflowCommand(program) {
-  const { workflowCommand } = await import('./workflow-ZB5Q2PFY.js');
+  const { workflowCommand } = await import('./workflow-H75N4BXX.js');
   program.addCommand(workflowCommand);
 }
 async function registerVulnCheckCommand(program) {
-  const { vulnCheckCommand } = await import('./vuln-check-TYQNEFS7.js');
+  const { vulnCheckCommand } = await import('./vuln-check-2W7N5TA2.js');
   program.addCommand(vulnCheckCommand);
 }
 async function registerTemplateCheckCommand(program) {
-  const { templateCheckCommand } = await import('./template-check-PNG5NQ5H.js');
+  const { templateCheckCommand } = await import('./template-check-3P4HZXVY.js');
   program.addCommand(templateCheckCommand);
 }
 async function registerSessionCommands(program) {
@@ -478,7 +503,15 @@ var COMMAND_GROUPS = [
     register: registerTestCommands
   },
   {
-    shouldRegister: (requested) => isRequestedCommand(requested, ["status", "check", "cache", "telemetry", "link", "unlink"]),
+    shouldRegister: (requested) => isRequestedCommand(requested, [
+      "status",
+      "check",
+      "doctor",
+      "cache",
+      "telemetry",
+      "link",
+      "unlink"
+    ]),
     register: registerStatusCheckAndUtilityCommands
   },
   {
@@ -530,9 +563,15 @@ var COMMAND_GROUPS = [
     register: registerSessionCommands
   }
 ];
+function shouldLoadAllCommands(requested, loadAllCommands) {
+  if (loadAllCommands === true || requested === null) {
+    return true;
+  }
+  return !COMMAND_GROUPS.some((group) => group.shouldRegister(requested));
+}
 async function registerSelectedCommands(program, options) {
   const requested = normalizeRequestedCommandName(options.requestedCommandName);
-  const shouldLoadAll = options.loadAllCommands === true || requested === null;
+  const shouldLoadAll = shouldLoadAllCommands(requested, options.loadAllCommands);
   for (const group of COMMAND_GROUPS) {
     if (shouldLoadAll || group.shouldRegister(requested)) {
       await group.register(program, requested, shouldLoadAll);
@@ -542,6 +581,7 @@ async function registerSelectedCommands(program, options) {
 var RUNTIME_BOOTSTRAP_OPTIONAL_COMMANDS = /* @__PURE__ */ new Set([
   "cache",
   "check",
+  "doctor",
   "inject-test-attrs",
   "link",
   "manifest",
@@ -552,6 +592,9 @@ var RUNTIME_BOOTSTRAP_OPTIONAL_COMMANDS = /* @__PURE__ */ new Set([
 function shouldRunRuntimeBootstrap(argv) {
   const requested = getRequestedCommandNameFromArgv(argv);
   if (!requested) return true;
+  if (!COMMAND_GROUPS.some((group) => group.shouldRegister(requested))) {
+    return false;
+  }
   if (RUNTIME_BOOTSTRAP_OPTIONAL_COMMANDS.has(requested)) {
     return false;
   }
@@ -646,7 +689,7 @@ async function executeProgram(program) {
   const isHelpOrVersion = argv.includes("--help") || argv.includes("-h") || argv.includes("--version") || argv.includes("-V");
   if (!isHelpOrVersion && shouldRunRuntimeBootstrap(argv)) {
     const [{ loadEnvFiles }, { enforceLicenseInCI }] = await Promise.all([
-      import('./env-files-K2C7O7L5.js'),
+      import('./env-files-2UIUYLLR.js'),
       import('./license-OB7GVJQ2.js')
     ]);
     loadEnvFiles({

package/dist/commands/build/actors/validate.d.ts

@@ -11,12 +11,14 @@
 export interface ValidateInput {
     repoRoot: string;
     skipManifest: boolean;
+    skipTables: boolean;
 }
 export interface ValidateOutput {
     passed: boolean;
     checks: {
         buildOutputs: boolean;
         manifests: boolean;
+        tables: boolean;
     };
     warnings: string[];
     error?: string;

package/dist/commands/check/commands/check.d.ts

@@ -13,14 +13,19 @@
  * - 1: Critical issues found (blocks operations)
  */
 import { Command } from 'commander';
-interface CheckOptions {
+export interface CheckOptions {
     scope?: 'all' | 'build' | 'ci' | 'deploy' | 'testing' | 'layer1' | 'layer2' | 'layer3' | 'layer4';
     fix?: boolean;
     verbose?: boolean;
     dryRun?: boolean;
     cwd?: string;
 }
-declare function runCheckAction(options: CheckOptions): Promise<void>;
-export { runCheckAction as runCheckCommand };
+interface RunCheckCommandOptions {
+    command: Command;
+    loggerName: string;
+    deprecationNotice?: string;
+}
+export declare function runCheckCommand(options: CheckOptions, runOptions: RunCheckCommandOptions): Promise<void>;
 export declare const checkCommand: Command;
+export {};
 //# sourceMappingURL=check.d.ts.map

package/dist/commands/ci/machine/actors/db/collect-schema-stats.d.ts

@@ -1,12 +1,11 @@
 /**
  * AI HINT: Collect Schema Stats Actor
  *
- * Purpose: Collect schema statistics from Local, CI, and Production databases
+ * Purpose: Collect schema statistics from Reference, CI, and Production databases
  * Pattern: Fine-grained actor for single step
  *
- * All environments use the same DB query logic for consistent comparison:
- * - Local stats: Query local Supabase DB (Docker)
- *   Note: Schema files include both declarative/*.sql AND idempotent/*.sql
+ * Comparison strategy:
+ * - Reference stats: Build a temporary reference DB from repo SQL, then query it
  * - CI stats: Query CI database (Docker Supabase or Branch DB)
  * - Production stats: Query Production DB (if GH_DATABASE_URL_ADMIN set)
  *
@@ -18,12 +17,16 @@
  */
 import { type SchemaStatsSnapshot } from './schema-stats.js';
 export interface CollectSchemaStatsInput {
-    /** Local database URL (Docker Supabase) */
-    localDbUrl: string | null;
+    /** Repository root (used to build a reference DB from repo SQL) */
+    repoRoot: string;
+    /** Reference source DB URL (used to create/drop temp DB) */
+    referenceDbUrl: string | null;
     /** CI database URL (Docker Supabase or Branch DB) */
     ciDbUrl: string | null;
     /** Whether to query production (requires GH_DATABASE_URL_ADMIN) */
     queryProduction: boolean;
+    /** Temporary directory for logs */
+    tmpDir: string;
 }
 export interface CollectSchemaStatsOutput {
     /** Schema statistics snapshot */