@runa-ai/runa-cli 0.7.0 → 0.7.2

package/dist/{cli-2JNBJUBB.js → cli-Q2XIQDRS.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-AIP6MR42.js';
+import { CLI_VERSION, HAS_ADMIN_COMMAND } from './chunk-PMXE5XOJ.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-ZIL6LRFO.js');
+      const { initCommand: initCommand2 } = await import('./init-S2ATHLJ6.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-NUK3ZBCL.js');
+      const { upgradeCommand: upgradeCommand2 } = await import('./upgrade-BDUWBRT5.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-V66FAQXB.js');
+      const { buildCommand: buildCommand2 } = await import('./build-HQMSVN6N.js');
       program.addCommand(buildCommand2);
       return;
     }
     if (requested === "dev") {
-      const { devCommand: devCommand2 } = await import('./dev-5YXNPTCJ.js');
+      const { devCommand: devCommand2 } = await import('./dev-MLRKIP7F.js');
       program.addCommand(devCommand2);
       return;
     }
@@ -183,12 +183,12 @@ async function registerProjectLifecycleCommands(program, requested, loadAllComma
     { buildCommand },
     { devCommand }
   ] = await Promise.all([
-    import('./init-ZIL6LRFO.js'),
+    import('./init-S2ATHLJ6.js'),
     import('./prepare-32DOVHTE.js'),
-    import('./upgrade-NUK3ZBCL.js'),
+    import('./upgrade-BDUWBRT5.js'),
     import('./validate-CAAW4Y44.js'),
-    import('./build-V66FAQXB.js'),
-    import('./dev-5YXNPTCJ.js')
+    import('./build-HQMSVN6N.js'),
+    import('./dev-MLRKIP7F.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-TMFLESHW.js');
+    const { manifestCommand } = await import('./manifest-EGCAZ4TK.js');
     program.addCommand(manifestCommand);
     return true;
   }
   if (requested === "inject-test-attrs") {
-    const { injectTestAttrsCommand } = await import('./inject-test-attrs-P44BVTQS.js');
+    const { injectTestAttrsCommand } = await import('./inject-test-attrs-XN4I2AOR.js');
     program.addCommand(injectTestAttrsCommand);
     return true;
   }
@@ -293,8 +293,8 @@ 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')
+    import('./inject-test-attrs-XN4I2AOR.js'),
+    import('./manifest-EGCAZ4TK.js')
   ]);
   const { injectTestAttrsCommand } = injectModule;
   const { manifestCommand } = manifestModule;
@@ -388,35 +388,8 @@ async function registerTestCommands(program, requested, loadAllCommands) {
 }
 async function registerStatusCheckAndUtilityCommands(program, requested, loadAllCommands) {
   if (!loadAllCommands && requested) {
-    if (requested === "status") {
-      const { statusCommand: statusCommand2 } = await import('./status-UTKS63AB.js');
-      program.addCommand(statusCommand2);
-      return;
-    }
-    if (requested === "check") {
-      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-N7WNPEYF.js');
-      program.addCommand(cacheCommand2);
-      return;
-    }
-    if (requested === "telemetry") {
-      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-VSNDVZZD.js');
-      program.addCommand(linkCommand2);
-      program.addCommand(unlinkCommand2);
+    const handled = await registerFocusedStatusUtilityCommand(program, requested);
+    if (handled) {
       return;
     }
   }
@@ -426,13 +399,15 @@ async function registerStatusCheckAndUtilityCommands(program, requested, loadAll
     { doctorCommand },
     { cacheCommand },
     { telemetryCommand },
+    { observabilityCommand },
     { linkCommand, unlinkCommand }
   ] = await Promise.all([
     import('./status-UTKS63AB.js'),
-    import('./check-LOMVIRHX.js'),
-    import('./doctor-MZLOA53G.js'),
+    import('./check-PCSQPYDM.js'),
+    import('./doctor-ROSWSMLH.js'),
     import('./cache-N7WNPEYF.js'),
     import('./telemetry-P56UBLZ2.js'),
+    import('./observability-CJA5UFIC.js'),
     import('./link-VSNDVZZD.js')
   ]);
   program.addCommand(statusCommand);
@@ -440,15 +415,58 @@ async function registerStatusCheckAndUtilityCommands(program, requested, loadAll
   program.addCommand(doctorCommand);
   program.addCommand(cacheCommand);
   program.addCommand(telemetryCommand);
+  program.addCommand(observabilityCommand);
   program.addCommand(linkCommand);
   program.addCommand(unlinkCommand);
 }
+async function registerFocusedStatusUtilityCommand(program, requested) {
+  if (!requested) {
+    return false;
+  }
+  if (requested === "status") {
+    const { statusCommand } = await import('./status-UTKS63AB.js');
+    program.addCommand(statusCommand);
+    return true;
+  }
+  if (requested === "check") {
+    const { checkCommand } = await import('./check-PCSQPYDM.js');
+    program.addCommand(checkCommand.name("check"));
+    return true;
+  }
+  if (requested === "doctor") {
+    const { doctorCommand } = await import('./doctor-ROSWSMLH.js');
+    program.addCommand(doctorCommand);
+    return true;
+  }
+  if (requested === "cache") {
+    const { cacheCommand } = await import('./cache-N7WNPEYF.js');
+    program.addCommand(cacheCommand);
+    return true;
+  }
+  if (requested === "telemetry") {
+    const { telemetryCommand } = await import('./telemetry-P56UBLZ2.js');
+    program.addCommand(telemetryCommand);
+    return true;
+  }
+  if (requested === "observability") {
+    const { observabilityCommand } = await import('./observability-CJA5UFIC.js');
+    program.addCommand(observabilityCommand);
+    return true;
+  }
+  if (requested === "link" || requested === "unlink") {
+    const { linkCommand, unlinkCommand } = await import('./link-VSNDVZZD.js');
+    program.addCommand(linkCommand);
+    program.addCommand(unlinkCommand);
+    return true;
+  }
+  return false;
+}
 async function registerCiCommand(program) {
-  const { ciCommand } = await import('./ci-ZWRVWNFX.js');
+  const { ciCommand } = await import('./ci-Z4525QW6.js');
   program.addCommand(ciCommand);
 }
 async function registerDbCommand(program) {
-  const { dbCommand } = await import('./db-XULCILOU.js');
+  const { dbCommand } = await import('./db-BPQ2TEQM.js');
   program.addCommand(dbCommand);
 }
 async function registerServicesCommand(program) {
@@ -456,11 +474,11 @@ async function registerServicesCommand(program) {
   program.addCommand(servicesCommand);
 }
 async function registerEnvCommand(program) {
-  const { envCommand } = await import('./env-SS66PZ4B.js');
+  const { envCommand } = await import('./env-WNHJVLOT.js');
   program.addCommand(envCommand);
 }
 async function registerHotfixCommand(program) {
-  const { hotfixCommand } = await import('./hotfix-YA3DGLOM.js');
+  const { hotfixCommand } = await import('./hotfix-Z5EGVSMH.js');
   program.addCommand(hotfixCommand);
 }
 async function registerSdkCommand(program) {
@@ -472,19 +490,19 @@ async function registerUiCommand(program) {
   program.addCommand(uiCommand);
 }
 async function registerWatchCommand(program) {
-  const { watchCommand } = await import('./watch-PNTKZYFB.js');
+  const { watchCommand } = await import('./watch-ITYW57SL.js');
   program.addCommand(watchCommand);
 }
 async function registerWorkflowCommand(program) {
-  const { workflowCommand } = await import('./workflow-H75N4BXX.js');
+  const { workflowCommand } = await import('./workflow-UZIZ2JUS.js');
   program.addCommand(workflowCommand);
 }
 async function registerVulnCheckCommand(program) {
-  const { vulnCheckCommand } = await import('./vuln-check-2W7N5TA2.js');
+  const { vulnCheckCommand } = await import('./vuln-check-66RXX3TO.js');
   program.addCommand(vulnCheckCommand);
 }
 async function registerTemplateCheckCommand(program) {
-  const { templateCheckCommand } = await import('./template-check-3P4HZXVY.js');
+  const { templateCheckCommand } = await import('./template-check-BDFMT6ZO.js');
   program.addCommand(templateCheckCommand);
 }
 async function registerSessionCommands(program) {
@@ -689,14 +707,14 @@ 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-2UIUYLLR.js'),
+      import('./env-files-HRNUGZ5O.js'),
       import('./license-OB7GVJQ2.js')
     ]);
     loadEnvFiles({
       silent: true
     });
     await enforceLicenseInCI();
-    await import('./env-HMMRSYCI.js');
+    await import('./env-XPPACZM4.js');
   }
   await program.parseAsync(process.argv);
 }

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

@@ -62,9 +62,9 @@ export declare function showSchemaDiff(repoRoot: string, tmpDir: string): Promis
  * Honors RUNA_SKIP_SCHEMA_RISK environment variable.
  * Provides actionable error messages for initial deployment scenarios.
  */
-export declare function detectRisks(repoRoot: string, tmpDir: string): Promise<void>;
-export declare function snapshotCreate(repoRoot: string, tmpDir: string, productionDbUrlAdmin: string, commit: string): Promise<void>;
-export declare function snapshotRestoreLatest(repoRoot: string, tmpDir: string, productionDbUrlAdmin: string): Promise<void>;
+export declare function detectRisks(repoRoot: string, tmpDir: string, timeoutMs?: number): Promise<void>;
+export declare function snapshotCreate(repoRoot: string, tmpDir: string, productionDbUrlAdmin: string, commit: string, timeoutMs?: number): Promise<void>;
+export declare function snapshotRestoreLatest(repoRoot: string, tmpDir: string, productionDbUrlAdmin: string, timeoutMs?: number): Promise<void>;
 /**
  * Schema apply options
  */
@@ -102,7 +102,9 @@ export interface SchemaApplyResult {
     /** Execution metrics (optional) */
     metrics?: SchemaApplyMetrics;
 }
-export declare function applyProductionSchema(repoRoot: string, tmpDir: string, productionDbUrlAdmin: string, productionDbUrl: string, options?: SchemaApplyOptions): Promise<SchemaApplyResult>;
+export declare function applyProductionSchema(repoRoot: string, tmpDir: string, productionDbUrlAdmin: string, productionDbUrl: string, options?: SchemaApplyOptions & {
+    timeoutMs?: number;
+}): Promise<SchemaApplyResult>;
 export declare function auditRecord(repoRoot: string, tmpDir: string, productionDbUrlAdmin: string, params: {
     commit: string;
     author: string;

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

@@ -21,6 +21,9 @@ export declare const CiProdApplyActionOptionsSchema: z.ZodObject<{
     allowDataLoss: z.ZodOptional<z.ZodBoolean>;
     confirmAuthzUpdate: z.ZodOptional<z.ZodBoolean>;
     maxLockWaitMs: z.ZodOptional<z.ZodNumber>;
+    riskTimeoutMs: z.ZodOptional<z.ZodNumber>;
+    snapshotTimeoutMs: z.ZodOptional<z.ZodNumber>;
+    applyTimeoutMs: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strict>;
 export type CiProdApplyActionOptions = z.infer<typeof CiProdApplyActionOptionsSchema>;
 //# sourceMappingURL=ci-prod-types.d.ts.map

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

@@ -1,4 +1,4 @@
-import { type createCLILogger } from '@runa-ai/runa';
+import type { createCLILogger } from '@runa-ai/runa/cli-runtime';
 import type { CiSummary } from '../utils/ci-summary.js';
 import type { ProdApplyInputs } from './ci-prod-utils.js';
 import type { CiProdApplyActionOptions } from './ci-prod-types.js';

package/dist/commands/ci/commands/ci-resolvers.d.ts

@@ -11,7 +11,7 @@
  * - This module used to be named `ci-pr-resolvers.ts`. It is now shared across CI commands.
  */
 import type { CiSummary } from '../utils/ci-summary.js';
-export type CiPrPhase = 'all' | 'test';
+export type CiPrPhase = 'all' | 'blocking' | 'observability' | 'test';
 export type CiDbMode = 'auto' | 'local';
 export type CiPrProfile = 'runa-strict' | 'pj-stable';
 export type CiPrPolicy = {

package/dist/commands/ci/commands/ci-supabase-local.d.ts

@@ -6,6 +6,7 @@
  * Note:
  * - This module used to be named `ci-pr-supabase-local.ts`. It is now shared across CI commands.
  */
+import type { SupabaseResolutionDiagnostics } from '../utils/ci-diagnostics.js';
 /**
  * Pre-flight check for port conflicts before starting Supabase.
  * Warns if DB port is already occupied by another Supabase instance.
@@ -14,6 +15,7 @@ export declare function checkSupabasePortConflicts(repoRoot: string): Promise<vo
 export declare function startSupabaseLocal(params: {
     repoRoot: string;
     tmpDir: string;
+    skipStart?: boolean;
 }): Promise<void>;
 export declare function stopSupabaseLocal(params: {
     repoRoot: string;
@@ -42,9 +44,11 @@ export declare const DEFAULT_LOCAL_ANON_KEY = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXV
 export declare function resolveLocalSupabaseEnv(params: {
     repoRoot: string;
     tmpDir: string;
+    assumeReady?: boolean;
 }): Promise<{
     supabaseUrl: string;
     anonKey: string;
+    diagnostics: SupabaseResolutionDiagnostics;
 }>;
 export declare function setupLocalDbRolesIfDrizzle(params: {
     repoRoot: string;

package/dist/commands/ci/machine/actors/build/build-and-playwright.d.ts

@@ -23,7 +23,7 @@ export interface BuildAndPlaywrightInput {
 }
 export interface BuildAndPlaywrightOutput {
     buildPassed: boolean;
-    manifestGenerated: boolean;
+    manifestGenerated: boolean | null;
     playwrightInstalled: boolean;
     buildError?: string;
     manifestError?: string;

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

@@ -5,7 +5,7 @@
  * Pattern: Fine-grained actor for single step
  *
  * Comparison strategy:
- * - Reference stats: Build a temporary reference DB from repo SQL, then query it
+ * - Reference stats: Build a temporary reference DB from repo SQL, or reuse the synced CI DB
  * - CI stats: Query CI database (Docker Supabase or Branch DB)
  * - Production stats: Query Production DB (if GH_DATABASE_URL_ADMIN set)
  *
@@ -15,7 +15,8 @@
  *
  * Results are used for PR comment Schema Status table.
  */
-import { type SchemaStatsSnapshot } from './schema-stats.js';
+import { type EnvironmentSchemaStats, type ExpectedDriftEntry, type SchemaStatsSnapshot } from './schema-stats.js';
+export type ReferenceStatsStrategy = 'rebuild' | 'reuse-ci';
 export interface CollectSchemaStatsInput {
     /** Repository root (used to build a reference DB from repo SQL) */
     repoRoot: string;
@@ -23,8 +24,14 @@ export interface CollectSchemaStatsInput {
     referenceDbUrl: string | null;
     /** CI database URL (Docker Supabase or Branch DB) */
     ciDbUrl: string | null;
+    /** How to resolve the reference schema snapshot */
+    referenceStrategy?: ReferenceStatsStrategy;
     /** Whether to query production (requires GH_DATABASE_URL_ADMIN) */
     queryProduction: boolean;
+    /** Collect CI semantic diff snapshots (expensive, optional in PR CI) */
+    includeCiSemantic?: boolean;
+    /** Expected drift entries used to decide whether semantic comparison is still necessary */
+    expectedDrift?: ExpectedDriftEntry[];
     /** Temporary directory for logs */
     tmpDir: string;
 }
@@ -32,6 +39,12 @@ export interface CollectSchemaStatsOutput {
     /** Schema statistics snapshot */
     schemaStats: SchemaStatsSnapshot;
 }
+export declare function shouldCollectProductionSemanticSnapshot(params: {
+    reference: EnvironmentSchemaStats;
+    production: EnvironmentSchemaStats | null;
+    expectedDrift?: ExpectedDriftEntry[];
+}): boolean;
+export declare function shouldCollectCiSemanticSnapshot(reference: EnvironmentSchemaStats, ci: EnvironmentSchemaStats): boolean;
 /**
  * Collect schema statistics from all environments.
  * All environments use the same DB query logic for consistent comparison.

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

@@ -4,31 +4,59 @@
  * Purpose: Run dry-run against production to preview schema changes
  * Pattern: Fine-grained actor for single step
  *
- * Runs `runa db apply production --check` to preview what SQL would be
+ * Runs `runa db apply production --check --compare-only` to preview what SQL would be
  * applied to production. Results are shown in PR comment.
  *
  * Prerequisites:
  * - GH_DATABASE_URL_ADMIN must be set (postgres role, DDL capable)
- * - Falls back to GH_DATABASE_URL if _ADMIN not set
  */
 import type { ProductionPreview } from '../../types.js';
 export interface ProductionPreviewInput {
     repoRoot: string;
     tmpDir: string;
-    /** Whether to execute (skip if GH_DATABASE_URL_ADMIN/GH_DATABASE_URL not set) */
+    /** Whether to execute (skip if GH_DATABASE_URL_ADMIN is not set) */
     shouldExecute: boolean;
 }
 export interface ProductionPreviewOutput {
     preview: ProductionPreview;
 }
+export type SchemaChangeState = 'changes' | 'no-changes' | 'unknown';
+/**
+ * Strip ANSI escape codes from string.
+ * Covers: colors, bold, underline, cursor movement, etc.
+ */
+export declare function stripAnsi(text: string): string;
+interface StructuredPreviewResult {
+    planSql: string | null;
+    filteredPlanSql: string | null;
+    hazards: string[];
+    hasChanges: boolean;
+    checkOnly: boolean;
+    metrics?: {
+        totalMs?: number;
+        idempotentMs?: number;
+        applyMs?: number;
+    };
+}
+export declare function tryParseStructuredOutput(stdout: string): StructuredPreviewResult | null;
+/**
+ * Detect whether db apply --check output indicates schema changes.
+ *
+ * Important:
+ * - "No changes were applied (check mode)" is always true in check mode and MUST NOT
+ *   be treated as "schema changes = none".
+ * - We prefer explicit change/no-change summary lines from db apply output.
+ */
+export declare function detectSchemaChangeState(fullOutput: string): SchemaChangeState;
 /**
  * Run production schema preview (dry-run).
  *
- * Uses `runa db apply production --check` to show what SQL would be applied
+ * Uses `runa db apply production --check --compare-only` to show what SQL would be applied
  * to production without actually applying changes.
  *
  * @param input - Preview parameters
  * @returns ProductionPreview with planSql, hazards, and hasChanges
  */
 export declare const productionPreviewActor: import("xstate").PromiseActorLogic<ProductionPreviewOutput, ProductionPreviewInput, import("xstate").EventObject>;
+export {};
 //# sourceMappingURL=production-preview.d.ts.map

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

@@ -11,7 +11,7 @@
  * - Indexes (definition, uniqueness, predicate)
  * - Triggers (definition)
  */
-export type CanonicalSchemaObjectKind = 'table' | 'function' | 'policy' | 'index' | 'trigger';
+export type CanonicalSchemaObjectKind = 'table' | 'function' | 'policy' | 'index' | 'trigger' | 'schema_acl' | 'schema_comment' | 'table_acl' | 'table_comment' | 'function_acl' | 'function_comment';
 export interface CanonicalSchemaObject {
     kind: CanonicalSchemaObjectKind;
     schema: string;
@@ -36,6 +36,12 @@ export interface CanonicalSchemaDiff {
     changed: CanonicalSchemaObjectPair[];
     renamed: CanonicalSchemaObjectPair[];
 }
+export interface CanonicalDriftClassification {
+    kinds: CanonicalSchemaObjectKind[];
+    structural: boolean;
+    securityMetadata: boolean;
+    descriptiveMetadata: boolean;
+}
 export interface SchemaSemanticSummary {
     hasChanges: boolean;
     changedKinds: CanonicalSchemaObjectKind[];
@@ -48,8 +54,31 @@ export interface SchemaSemanticSummary {
 }
 export type CanonicalDiffBySchema = Record<string, SchemaSemanticSummary>;
 export declare function createUnavailableCanonicalSnapshot(error: string): CanonicalSchemaSnapshot;
+interface TableColumnRow {
+    schema_name: string;
+    table_name: string;
+    attnum: number;
+    column_name: string;
+    data_type: string;
+    not_null: boolean;
+    default_expr?: string | null;
+    identity_kind?: string | null;
+    generated_kind?: string | null;
+}
+interface CanonicalTableColumnPayload {
+    name: string;
+    type: string;
+    notNull: boolean;
+    default: string;
+    identity: string;
+    generated: string;
+}
+export declare function createCanonicalTableColumnPayload(row: Pick<TableColumnRow, 'column_name' | 'data_type' | 'not_null' | 'default_expr' | 'identity_kind' | 'generated_kind'>): CanonicalTableColumnPayload;
+export declare function sortCanonicalTableColumns(columns: readonly CanonicalTableColumnPayload[]): CanonicalTableColumnPayload[];
 export declare function getCanonicalSchemaSnapshot(databaseUrl: string): Promise<CanonicalSchemaSnapshot>;
 export declare function compareCanonicalSnapshots(reference: CanonicalSchemaSnapshot, target: CanonicalSchemaSnapshot): CanonicalSchemaDiff;
 export declare function summarizeCanonicalDiffBySchema(diff: CanonicalSchemaDiff): CanonicalDiffBySchema;
 export declare function hasCanonicalChanges(diff: CanonicalSchemaDiff): boolean;
+export declare function classifyCanonicalDiff(diff: CanonicalSchemaDiff): CanonicalDriftClassification;
+export {};
 //# sourceMappingURL=schema-canonical-diff.d.ts.map

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

@@ -32,6 +32,7 @@ export interface SyncSchemaInput {
     databaseUrl: string;
     mode: CiMode;
     skipCodegen?: boolean;
+    skipPostCheck?: boolean;
 }
 export interface SyncSchemaOutput {
     applied: boolean;

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

@@ -5,5 +5,4 @@
  * Pattern: Barrel export for clean imports
  */
 export { type AddLabelsInput, type AddLabelsOutput, addLabelsActor, buildWorkflowRunUrl, type FindPrInput, type FindPrOutput, findPrActor, type RepoContext, resolveRepoContextFromEnv, type UpsertCommentInput, type UpsertCommentOutput, upsertCommentActor, } from './github.js';
-export { type CiLayerStatus, CiLayerStatusSchema, type CiStepStatus, CiStepStatusSchema, type CiSummary, CiSummarySchema, type LayerBlockingLevel, LayerBlockingLevelSchema, type WriteSummaryInput, type WriteSummaryOutput, writeSummaryActor, } from './summary.js';
 //# sourceMappingURL=index.d.ts.map

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

@@ -8,7 +8,7 @@
  * - db/*: Database operations (reset, sync, seeds, roles, pgtap, pull-production)
  * - build/*: Build operations (static-checks, app-build, app-start, playwright)
  * - test/*: Test operations (capabilities, run-layers)
- * - finalize/*: Finalization (summary, github)
+ * - finalize/*: Finalization (github reporting)
  */
 export * from './build/index.js';
 export * from './db/index.js';

package/dist/commands/ci/machine/actors/setup/local.d.ts

@@ -12,6 +12,7 @@
  *
  * Used only in ci-local mode (runa ci local).
  */
+import type { CiDiagnostics } from '../../../utils/ci-diagnostics.js';
 export interface LocalSetupInput {
     targetDir?: string;
     layer?: string;
@@ -29,6 +30,7 @@ export interface LocalSetupOutput {
     supabaseUrl: string;
     anonKey: string;
     layers: number[];
+    diagnostics?: CiDiagnostics;
     error?: string;
 }
 /**

package/dist/commands/ci/machine/actors/setup/pr-common.d.ts

@@ -14,6 +14,7 @@
  * - resolvePolicy: Resolve CI policy from config or defaults
  * - detectApp: Detect app configuration for E2E tests
  */
+import type { CiDiagnostics } from '../../../utils/ci-diagnostics.js';
 import type { ExpectedDriftEntry } from '../../actors/db/schema-stats.js';
 import type { CiPrPolicy, DetectedApp, PrContext, RepoKind } from '../../types.js';
 /**
@@ -96,6 +97,7 @@ export interface PrSetupBaseInput {
     config?: unknown;
     verbose?: boolean;
     layers?: number[];
+    skipPlaywrightInstall?: boolean;
     githubRef?: string;
     githubEventAction?: string;
     githubSha?: string;
@@ -117,6 +119,7 @@ export interface PrSetupBaseOutput {
     anonKey: string;
     layers: number[];
     expectedDrift: ExpectedDriftEntry[];
+    diagnostics?: CiDiagnostics;
     error?: string;
 }
 /**

package/dist/commands/ci/machine/actors/setup/pr-local.d.ts

@@ -7,6 +7,8 @@
 import type { PrSetupBaseInput, PrSetupBaseOutput } from './pr-common.js';
 export interface PrLocalSetupInput extends PrSetupBaseInput {
     databaseUrl?: string;
+    skipLocalDbStart?: boolean;
+    assumeSupabaseReady?: boolean;
 }
 export interface PrLocalSetupOutput extends PrSetupBaseOutput {
 }

package/dist/commands/ci/machine/commands/machine-runner.d.ts

@@ -10,8 +10,14 @@
  * - Fire-and-forget pattern (non-blocking)
  */
 import type { CLILogger } from '@runa-ai/runa';
+import { type CiStep, type StepTimings } from '../formatters/github-comment.js';
 import { type CiSnapshot } from '../machine.js';
 import type { CiInput, CiOutput, LayerResult } from '../types.js';
+export declare function resolveStepForState(state: string): CiStep | undefined;
+/**
+ * Get completed steps based on current step.
+ */
+export declare function getCompletedSteps(currentStep: CiStep, stepTimings?: StepTimings): CiStep[];
 /**
  * State change callback type.
  */

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

@@ -0,0 +1,16 @@
+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 declare function pickPrimaryStatePath(statePaths: string[], previousStatePath?: string): string | undefined;
+export interface StepTelemetryTracker {
+    transition: (statePaths: string[], nowMs?: number) => void;
+    finalize: (params: {
+        context: CiContext;
+        succeeded: boolean;
+        failedStatePath?: string | null;
+        nowMs?: number;
+    }) => Record<string, StepSummary>;
+}
+export declare function createStepTelemetryTracker(): StepTelemetryTracker;
+//# sourceMappingURL=step-telemetry.d.ts.map