@runa-ai/runa-cli 0.8.0 → 0.9.0

package/dist/{cli-ZY5VRIJA.js → cli-TJZCAMB2.js}

@@ -2,7 +2,7 @@
 import { createRequire } from 'module';
 import { enableNonInteractiveMode } from './chunk-6Y3LAUGL.js';
 import { getRequestedCommandNameFromArgv } from './chunk-UWWSAPDR.js';
-import { CLI_VERSION, HAS_ADMIN_COMMAND } from './chunk-GHQH6UC5.js';
+import { CLI_VERSION, HAS_ADMIN_COMMAND } from './chunk-GKBE7EIE.js';
 import { emitDefaultSuccessIfNeeded } from './chunk-WJXC4MVY.js';
 import { parseOutputFormat, setOutputFormat, getOutputFormatFromEnv } from './chunk-HKUWEGUX.js';
 import { init_esm_shims } from './chunk-VRXHCR5K.js';
@@ -145,7 +145,7 @@ function isTestCommand(requested) {
 async function registerProjectLifecycleCommands(program, requested, loadAllCommands) {
   if (!loadAllCommands && requested) {
     if (requested === "init") {
-      const { initCommand: initCommand2 } = await import('./init-35JLDFHI.js');
+      const { initCommand: initCommand2 } = await import('./init-2O6ODG5Z.js');
       program.addCommand(initCommand2);
       return;
     }
@@ -155,7 +155,7 @@ async function registerProjectLifecycleCommands(program, requested, loadAllComma
       return;
     }
     if (requested === "upgrade") {
-      const { upgradeCommand: upgradeCommand2 } = await import('./upgrade-7L4JIE4K.js');
+      const { upgradeCommand: upgradeCommand2 } = await import('./upgrade-QZKEI3NJ.js');
       program.addCommand(upgradeCommand2);
       return;
     }
@@ -165,12 +165,12 @@ async function registerProjectLifecycleCommands(program, requested, loadAllComma
       return;
     }
     if (requested === "build") {
-      const { buildCommand: buildCommand2 } = await import('./build-HQMSVN6N.js');
+      const { buildCommand: buildCommand2 } = await import('./build-P2A6345N.js');
       program.addCommand(buildCommand2);
       return;
     }
     if (requested === "dev") {
-      const { devCommand: devCommand2 } = await import('./dev-GB5ERUVR.js');
+      const { devCommand: devCommand2 } = await import('./dev-LGSMDFJN.js');
       program.addCommand(devCommand2);
       return;
     }
@@ -183,12 +183,12 @@ async function registerProjectLifecycleCommands(program, requested, loadAllComma
     { buildCommand },
     { devCommand }
   ] = await Promise.all([
-    import('./init-35JLDFHI.js'),
+    import('./init-2O6ODG5Z.js'),
     import('./prepare-32DOVHTE.js'),
-    import('./upgrade-7L4JIE4K.js'),
+    import('./upgrade-QZKEI3NJ.js'),
     import('./validate-CAAW4Y44.js'),
-    import('./build-HQMSVN6N.js'),
-    import('./dev-GB5ERUVR.js')
+    import('./build-P2A6345N.js'),
+    import('./dev-LGSMDFJN.js')
   ]);
   program.addCommand(initCommand);
   program.addCommand(prepareCommand);
@@ -208,12 +208,12 @@ var TEST_GENERATION_COMMANDS = /* @__PURE__ */ new Set([
 ]);
 async function addSingleTestCommand(program, requested) {
   if (requested === "manifest") {
-    const { manifestCommand } = await import('./manifest-EGCAZ4TK.js');
+    const { manifestCommand } = await import('./manifest-CI4BRWEB.js');
     program.addCommand(manifestCommand);
     return true;
   }
   if (requested === "inject-test-attrs") {
-    const { injectTestAttrsCommand } = await import('./inject-test-attrs-XN4I2AOR.js');
+    const { injectTestAttrsCommand } = await import('./inject-test-attrs-F5A346UV.js');
     program.addCommand(injectTestAttrsCommand);
     return true;
   }
@@ -234,7 +234,7 @@ async function addSingleTestCommand(program, requested) {
   return true;
 }
 async function registerFocusedTestCommand(program, requested) {
-  const testModule = await import('./test-V4KQL574.js');
+  const testModule = await import('./test-QCPN6Z47.js');
   const {
     testCommand,
     testDbCommand,
@@ -291,10 +291,10 @@ async function registerFocusedTestCommand(program, requested) {
 }
 async function registerAllTestCommands(program) {
   const [testModule, testGenModule, injectModule, manifestModule] = await Promise.all([
-    import('./test-V4KQL574.js'),
+    import('./test-QCPN6Z47.js'),
     import('./test-gen-FS4CEY3P.js'),
-    import('./inject-test-attrs-XN4I2AOR.js'),
-    import('./manifest-EGCAZ4TK.js')
+    import('./inject-test-attrs-F5A346UV.js'),
+    import('./manifest-CI4BRWEB.js')
   ]);
   const { injectTestAttrsCommand } = injectModule;
   const { manifestCommand } = manifestModule;
@@ -403,11 +403,11 @@ async function registerStatusCheckAndUtilityCommands(program, requested, loadAll
     { linkCommand, unlinkCommand }
   ] = await Promise.all([
     import('./status-UTKS63AB.js'),
-    import('./check-PCSQPYDM.js'),
-    import('./doctor-ROSWSMLH.js'),
+    import('./check-4TZHNOZU.js'),
+    import('./doctor-GYX73IEW.js'),
     import('./cache-N7WNPEYF.js'),
     import('./telemetry-P56UBLZ2.js'),
-    import('./observability-CJA5UFIC.js'),
+    import('./observability-WNSCJ5FV.js'),
     import('./link-VSNDVZZD.js')
   ]);
   program.addCommand(statusCommand);
@@ -429,12 +429,12 @@ async function registerFocusedStatusUtilityCommand(program, requested) {
     return true;
   }
   if (requested === "check") {
-    const { checkCommand } = await import('./check-PCSQPYDM.js');
+    const { checkCommand } = await import('./check-4TZHNOZU.js');
     program.addCommand(checkCommand.name("check"));
     return true;
   }
   if (requested === "doctor") {
-    const { doctorCommand } = await import('./doctor-ROSWSMLH.js');
+    const { doctorCommand } = await import('./doctor-GYX73IEW.js');
     program.addCommand(doctorCommand);
     return true;
   }
@@ -449,7 +449,7 @@ async function registerFocusedStatusUtilityCommand(program, requested) {
     return true;
   }
   if (requested === "observability") {
-    const { observabilityCommand } = await import('./observability-CJA5UFIC.js');
+    const { observabilityCommand } = await import('./observability-WNSCJ5FV.js');
     program.addCommand(observabilityCommand);
     return true;
   }
@@ -462,11 +462,11 @@ async function registerFocusedStatusUtilityCommand(program, requested) {
   return false;
 }
 async function registerCiCommand(program) {
-  const { ciCommand } = await import('./ci-ZK3LKYFX.js');
+  const { ciCommand } = await import('./ci-S5KSBECX.js');
   program.addCommand(ciCommand);
 }
 async function registerDbCommand(program) {
-  const { dbCommand } = await import('./db-EPI2DQYN.js');
+  const { dbCommand } = await import('./db-D2OLJDYW.js');
   program.addCommand(dbCommand);
 }
 async function registerServicesCommand(program) {
@@ -474,15 +474,15 @@ async function registerServicesCommand(program) {
   program.addCommand(servicesCommand);
 }
 async function registerEnvCommand(program) {
-  const { envCommand } = await import('./env-WP74UUMO.js');
+  const { envCommand } = await import('./env-KYR6Q7WO.js');
   program.addCommand(envCommand);
 }
 async function registerHotfixCommand(program) {
-  const { hotfixCommand } = await import('./hotfix-TOSGTVCW.js');
+  const { hotfixCommand } = await import('./hotfix-RJIAPLAM.js');
   program.addCommand(hotfixCommand);
 }
 async function registerSdkCommand(program) {
-  const { sdkCommand } = await import('./sdk-XK6HQU7S.js');
+  const { sdkCommand } = await import('./sdk-BTIVPEE5.js');
   program.addCommand(sdkCommand);
 }
 async function registerUiCommand(program) {
@@ -490,15 +490,15 @@ async function registerUiCommand(program) {
   program.addCommand(uiCommand);
 }
 async function registerWatchCommand(program) {
-  const { watchCommand } = await import('./watch-AL4LCBRM.js');
+  const { watchCommand } = await import('./watch-RFVCEQLH.js');
   program.addCommand(watchCommand);
 }
 async function registerWorkflowCommand(program) {
-  const { workflowCommand } = await import('./workflow-UZIZ2JUS.js');
+  const { workflowCommand } = await import('./workflow-UOG6ZZMH.js');
   program.addCommand(workflowCommand);
 }
 async function registerVulnCheckCommand(program) {
-  const { vulnCheckCommand } = await import('./vuln-check-G6I4YYDC.js');
+  const { vulnCheckCommand } = await import('./vuln-check-5NUTETPW.js');
   program.addCommand(vulnCheckCommand);
 }
 async function registerTemplateCheckCommand(program) {
@@ -707,7 +707,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-HRNUGZ5O.js'),
+      import('./env-files-ONBC47I6.js'),
       import('./license-OB7GVJQ2.js')
     ]);
     loadEnvFiles({

package/dist/commands/ci/commands/ci-prod-db-operations.d.ts

@@ -8,6 +8,7 @@
  * - Uses getFilteredEnv() instead of ...process.env to prevent secret leakage
  * - Database URLs passed as required secrets only to commands that need them
  */
+import type { DbApplyPlanner } from '../../db/apply/contract.js';
 export declare function detectStack(repoRoot: string, tmpDir: string, productionDbUrlAdmin: string): Promise<string>;
 /**
  * Initial deployment detection result
@@ -24,6 +25,13 @@ export interface InitialDeploymentCheck {
     /** Whether the check was successful (DB accessible) */
     checkSuccessful: boolean;
 }
+export interface SchemaChangeSummary {
+    /** null = unable to determine, false = no diff, true = diff exists */
+    hasChanges: boolean | null;
+    diffLogPath: string | null;
+    targetLabel: string | null;
+    diffPaths: string[];
+}
 /**
  * Check if this is an initial deployment by verifying app tables exist in production DB.
  *
@@ -40,22 +48,7 @@ export interface InitialDeploymentCheck {
  * @returns Detection result with details
  */
 export declare function checkIfInitialDeployment(repoRoot: string, productionDbUrl: string): InitialDeploymentCheck;
-/**
- * Check if there are any schema changes between origin/main and HEAD.
- * Uses git diff --quiet (exit 1 = changes exist, exit 0 = no changes).
- *
- * Returns:
- * - true: schema changes detected
- * - false: no schema changes (confirmed via git diff)
- * - null: unable to determine (no schema dir found, or git error)
- *         Callers should treat null as "unknown" and NOT skip steps.
- *
- * Detection order (SQL-First Architecture):
- * 1. supabase/schemas/declarative/ + idempotent/ (SSOT)
- * 2. Drizzle TypeScript schemas (legacy fallback)
- */
-export declare function hasSchemaChanges(repoRoot: string): boolean | null;
-export declare function showSchemaDiff(repoRoot: string, tmpDir: string): Promise<void>;
+export declare function collectSchemaChangeSummary(repoRoot: string, tmpDir: string): Promise<SchemaChangeSummary>;
 /**
  * Detect risky schema changes via git diff analysis.
  *
@@ -97,10 +90,12 @@ export interface SchemaApplyResult {
     hazards: string[];
     /** Summary of changes (e.g., "2 policies updated, 1 index created") */
     changeSummary: string;
-    /** Path to the log file */
+    /** Path to the structured apply result artifact */
     logPath: string;
     /** Execution metrics (optional) */
     metrics?: SchemaApplyMetrics;
+    /** Planner artifact / reuse telemetry (optional) */
+    planner?: DbApplyPlanner;
 }
 export declare function applyProductionSchema(repoRoot: string, tmpDir: string, productionDbUrlAdmin: string, productionDbUrl: string, options?: SchemaApplyOptions & {
     timeoutMs?: number;

package/dist/commands/ci/commands/ci-prod-utils.d.ts

@@ -5,6 +5,11 @@
  * Used by: ci-prod-apply.ts
  */
 import type { CiSummary } from '../utils/ci-summary.js';
+interface CiProdApplyFailureMetadata {
+    code: string;
+    message: string;
+    retryable: boolean;
+}
 export declare function requireEnv(name: string): string;
 export declare function resolveRepoKind(): 'monorepo' | 'pj-repo' | 'unknown';
 export declare function createInitialSummary(params: {
@@ -25,9 +30,11 @@ export interface ProdApplyInputs {
     githubRepository: string;
 }
 export declare function resolveProdApplyInputs(): ProdApplyInputs;
+export declare function classifyCiProdApplyError(error: unknown): CiProdApplyFailureMetadata;
 export declare function setSummaryErrorFromUnknown(summary: CiSummary, error: unknown): void;
 export declare function buildCiProdApplyStepSummaryMarkdown(params: {
     summary: CiSummary;
     summaryPath: string;
 }): string;
+export {};
 //# sourceMappingURL=ci-prod-utils.d.ts.map

package/dist/commands/ci/commands/layer4-discovery.d.ts

@@ -0,0 +1,2 @@
+export { resolveLayer4DiscoverySync } from '@runa-ai/runa/test-config';
+//# sourceMappingURL=layer4-discovery.d.ts.map

package/dist/commands/ci/machine/actors/db/production-preview.d.ts

@@ -4,7 +4,7 @@
  * Purpose: Run dry-run against production to preview schema changes
  * Pattern: Fine-grained actor for single step
  *
- * Runs `runa db apply production --check --compare-only` to preview what SQL would be
+ * Runs `runa db preview production --profile compare-only` to preview what SQL would be
  * applied to production. Results are shown in PR comment.
  *
  * Prerequisites:
@@ -32,6 +32,7 @@ interface StructuredPreviewResult {
     hazards: string[];
     hasChanges: boolean;
     checkOnly: boolean;
+    previewProfile: 'compare-only' | 'full' | null;
     metrics?: {
         totalMs?: number;
         idempotentMs?: number;
@@ -40,7 +41,7 @@ interface StructuredPreviewResult {
 }
 export declare function tryParseStructuredOutput(stdout: string): StructuredPreviewResult | null;
 /**
- * Detect whether db apply --check output indicates schema changes.
+ * Detect whether db preview output indicates schema changes.
  *
  * Important:
  * - "No changes were applied (check mode)" is always true in check mode and MUST NOT
@@ -51,7 +52,7 @@ export declare function detectSchemaChangeState(fullOutput: string): SchemaChang
 /**
  * Run production schema preview (dry-run).
  *
- * Uses `runa db apply production --check --compare-only` to show what SQL would be applied
+ * Uses `runa db preview production --profile compare-only` to show what SQL would be applied
  * to production without actually applying changes.
  *
  * @param input - Preview parameters

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

@@ -25,7 +25,7 @@
  * - Captures hazards from pg-schema-diff
  * - Reports all changes in PR comment
  */
-import type { CiMode, SchemaChangeStats, SchemaDriftSnapshot } from '../../types.js';
+import type { CiMode, SchemaChangeStats, SchemaDriftSnapshot, SchemaGitDiff } from '../../types.js';
 export interface SyncSchemaInput {
     repoRoot: string;
     tmpDir: string;
@@ -39,6 +39,10 @@ export interface SyncSchemaOutput {
     error?: string;
     schemaDrift?: SchemaDriftSnapshot;
 }
+/**
+ * Build a schema git diff snapshot from a unified patch diff.
+ */
+export declare function extractSchemaGitDiffSnapshot(diffOutput: string): SchemaGitDiff | null;
 export declare function analyzePostCheckResult(params: {
     exitCode: number;
     output: string;

package/dist/commands/ci/machine/actors/test/capabilities.d.ts

@@ -6,7 +6,6 @@
  *
  * Only used in ci-pr-local mode (not ci-local):
  * - Detect DB, E2E, preview capabilities
- * - Detect layer content (machines, tables, API routes, pages)
  *
  * Capabilities detected:
  * - db.postgres, db.schemaApplied, db.rlsEnabled
@@ -15,33 +14,23 @@
  * - e2e.generatedLayer4Present, e2e.generatedLayer4HasUnknown
  * - e2e.previewReachable
  *
- * Layer content detection:
- * - L1: XState machines
- * - L2: Domain tables (SQL)
- * - L3: API routes (Hono)
- * - L4: User-facing pages
  */
 import { type CiCapabilities, type CiCapability } from '../../../commands/ci-pr-capabilities.js';
-import { type LayerContentResult } from '../../../commands/ci-layer-content.js';
 export interface CapabilitiesInput {
     repoRoot: string;
     tmpDir: string;
     databaseUrlApp: string;
     baseUrl: string | null;
-    /** Selected layers for content detection */
-    selectedLayers: number[];
 }
 export interface CapabilitiesOutput {
     detected: CiCapabilities;
-    /** Layer content detection result */
-    layerContent: LayerContentResult;
     error?: string;
 }
 /**
- * Detect CI capabilities and layer content.
+ * Detect CI capabilities.
  *
  * @param input - Detection parameters
- * @returns Detected capabilities and layer content
+ * @returns Detected capabilities
  */
 export declare const capabilitiesActor: import("xstate").PromiseActorLogic<CapabilitiesOutput, CapabilitiesInput, import("xstate").EventObject>;
 export interface AssertCapabilitiesInput {

package/dist/commands/ci/machine/actors/test/index.d.ts

@@ -5,5 +5,6 @@
  * Pattern: Barrel export for clean imports
  */
 export { type AssertCapabilitiesInput, type AssertCapabilitiesOutput, assertCapabilitiesActor, type CapabilitiesInput, type CapabilitiesOutput, capabilitiesActor, } from './capabilities.js';
+export { type LayerContentInput, type LayerContentOutput, layerContentActor, } from './layer-content.js';
 export { type LayerRunResult, type RunLayersInput, type RunLayersOutput, runLayersActor, } from './run-layers.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/commands/ci/machine/actors/test/layer-content.d.ts

@@ -0,0 +1,11 @@
+import { type LayerContentResult } from '../../../commands/ci-layer-content.js';
+export interface LayerContentInput {
+    repoRoot: string;
+    selectedLayers: number[];
+}
+export interface LayerContentOutput {
+    layerContent: LayerContentResult;
+    error?: string;
+}
+export declare const layerContentActor: import("xstate").PromiseActorLogic<LayerContentOutput, LayerContentInput, import("xstate").EventObject>;
+//# sourceMappingURL=layer-content.d.ts.map

package/dist/commands/ci/machine/commands/ci-pr-internal-profile.d.ts

@@ -0,0 +1,7 @@
+export type InternalCiProfile = 'schema-only';
+export interface InternalCiOverrides {
+    profile?: InternalCiProfile;
+    layers?: number[];
+}
+export declare function resolveInternalCiOverrides(env?: NodeJS.ProcessEnv): InternalCiOverrides;
+//# sourceMappingURL=ci-pr-internal-profile.d.ts.map

package/dist/commands/ci/machine/commands/ci-step-registry.d.ts

@@ -0,0 +1,25 @@
+import type { CiStep } from '../formatters/github-comment.js';
+import type { StepSummary } from '../contract.js';
+export type StepPhase = 'setup' | 'github' | 'db' | 'observability' | 'build' | 'test' | 'finalize';
+export interface StepMetadata {
+    order: number;
+    title: string;
+    phase: StepPhase;
+    optional?: boolean;
+    parentStep?: string;
+}
+export declare const PROGRESS_STATE_TO_STEP: Record<string, CiStep>;
+export declare const PROGRESS_STEP_ORDER: CiStep[];
+export declare const OBSERVABILITY_STEP_IDS: readonly ["postSeedPr.observability.productionPreview", "postSeedPr.observability.collectSchemaStats"];
+export declare const EXECUTION_STEP_IDS: readonly ["postSeedPr.execution.setupRoles", "postSeedPr.execution.staticChecks", "postSeedPr.execution.layerContent", "postSeedPr.execution.buildAndPlaywright", "postSeedPr.execution.appStart", "postSeedPr.execution.capabilities", "postSeedPr.execution.runCoreTests", "postSeedPr.execution.e2ePhase"];
+export declare const BUILD_PREPARATION_SUBSTEP_IDS: {
+    readonly build: "postSeedPr.execution.buildAndPlaywright.build";
+    readonly manifestGenerate: "postSeedPr.execution.buildAndPlaywright.manifestGenerate";
+    readonly playwrightInstall: "postSeedPr.execution.buildAndPlaywright.playwrightInstall";
+};
+export declare const STEP_METADATA: Record<string, StepMetadata>;
+export declare function getStepMetadata(stepId: string): StepMetadata | undefined;
+export declare function getCanonicalStepId(statePath: string): string | null;
+export declare function getStepOrderFromStatePath(statePath: string): number;
+export type InternalStepStatus = StepSummary['status'] | 'running';
+//# sourceMappingURL=ci-step-registry.d.ts.map

package/dist/commands/ci/machine/commands/step-telemetry.d.ts

@@ -1,7 +1,6 @@
 import type { StepSummary } from '../contract.js';
 import type { CiContext } from '../types.js';
-export declare function getCanonicalStepId(statePath: string): string | null;
-export declare function getStepOrderFromStatePath(statePath: string): number;
+export { getCanonicalStepId, getStepOrderFromStatePath } from './ci-step-registry.js';
 export declare function pickPrimaryStatePath(statePaths: string[], previousStatePath?: string): string | undefined;
 export interface StepTelemetryTracker {
     transition: (statePaths: string[], nowMs?: number) => void;

package/dist/commands/ci/machine/contract.d.ts

@@ -131,6 +131,9 @@ export declare const CiInputSchema: z.ZodObject<{
     playwrightWorkers: z.ZodOptional<z.ZodString>;
     skipGithubComment: z.ZodOptional<z.ZodBoolean>;
     layers: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+    internalProfile: z.ZodOptional<z.ZodEnum<{
+        "schema-only": "schema-only";
+    }>>;
 }, z.core.$loose>;
 export type CiInput = z.infer<typeof CiInputSchema>;
 /**

package/dist/commands/ci/machine/guards.d.ts

@@ -22,13 +22,11 @@ import type { CiContext, CiInput, CiMode } from './types.js';
  */
 export declare function isCiLocalMode(context: CiContext): boolean;
 /**
- * Check if running ci-pr-local mode.
- */
-export declare function isCiPrLocalMode(context: CiContext): boolean;
-/**
- * Check if running ci-pr mode.
+ * Check if running ci-pr mode (ci-pr-local).
  */
 export declare function isCiPrMode(context: CiContext): boolean;
+/** @deprecated Use isCiPrMode instead (identical logic). */
+export declare const isCiPrLocalMode: typeof isCiPrMode;
 /**
  * Resolve the effective CI mode from input and environment.
  *
@@ -38,11 +36,6 @@ export declare function isCiPrMode(context: CiContext): boolean;
  */
 export declare function resolveMode(params: {
     command: 'local' | 'pr';
-    dbMode: 'auto' | 'local';
-    hasBranchInputs: boolean;
-    allowLocalFallback: boolean;
-    isGitHubActions: boolean;
-    hasPrContext: boolean;
 }): CiMode;
 /**
  * Check if static checks should be skipped.

package/dist/commands/ci/machine/helpers.d.ts

@@ -49,7 +49,7 @@ export declare function hasSchemaGitChanges(context: CiContext): boolean;
  * Skip the expensive post-apply check in GitHub Actions PR preview runs.
  *
  * Preview CI always starts from a fresh local Supabase instance on an ephemeral
- * runner, so re-running `db apply --check` immediately after a successful apply
+ * runner, so re-running `db preview` immediately after a successful apply
  * does not add meaningful signal on the critical path.
  */
 export declare function shouldSkipSchemaPostCheck(context: CiContext): boolean;

package/dist/commands/ci/machine/machine-execution-helpers.d.ts

@@ -14,6 +14,10 @@ export declare function createStaticChecksInput(context: CiContext): {
     repoRoot: string;
     tmpDir: string;
 };
+export declare function createLayerContentInput(context: CiContext): {
+    repoRoot: string;
+    selectedLayers: number[];
+};
 export declare function createBuildAndPlaywrightInput(context: CiContext): {
     repoRoot: string;
     tmpDir: string;
@@ -32,8 +36,7 @@ export declare function createCapabilitiesInput(context: CiContext): {
     repoRoot: string;
     tmpDir: string;
     databaseUrlApp: string;
-    baseUrl: string;
-    selectedLayers: number[];
+    baseUrl: string | null;
 };
 export declare function createRunCoreTestsInput(context: CiContext): RunLayersInput;
 export declare function deriveCoreLayerResults(output: RunLayersOutput): Record<number, LayerResult>;