@runa-ai/runa-cli 0.7.0 → 0.7.2

package/dist/commands/db/sync/contract.d.ts

@@ -37,10 +37,13 @@ export declare const DbSyncInputSchema: z.ZodObject<{
     verbose: z.ZodDefault<z.ZodBoolean>;
     skipCodegen: z.ZodDefault<z.ZodBoolean>;
     strictIntrospect: z.ZodDefault<z.ZodBoolean>;
+    strict: z.ZodDefault<z.ZodBoolean>;
     targetDir: z.ZodOptional<z.ZodString>;
     fromProduction: z.ZodDefault<z.ZodBoolean>;
     autoSnapshot: z.ZodDefault<z.ZodBoolean>;
     reportJson: z.ZodOptional<z.ZodString>;
+    snapshotTimeoutMs: z.ZodOptional<z.ZodNumber>;
+    syncTimeoutMs: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strict>;
 export type DbSyncInput = z.infer<typeof DbSyncInputSchema>;
 /**
@@ -109,11 +112,14 @@ export declare const StepContextSchema: z.ZodObject<{
     verbose: z.ZodBoolean;
     skipCodegen: z.ZodBoolean;
     strictIntrospect: z.ZodBoolean;
+    strict: z.ZodBoolean;
     fromProduction: z.ZodBoolean;
     autoSnapshot: z.ZodBoolean;
     noSeed: z.ZodBoolean;
     reportJson: z.ZodOptional<z.ZodString>;
     timeoutMs: z.ZodOptional<z.ZodNumber>;
+    snapshotTimeoutMs: z.ZodOptional<z.ZodNumber>;
+    syncTimeoutMs: z.ZodOptional<z.ZodNumber>;
     configTimeoutMs: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>;
 export type StepContext = z.infer<typeof StepContextSchema>;
@@ -135,6 +141,77 @@ export declare const DbSyncOutputSchema: z.ZodObject<{
     reportJsonPath: z.ZodOptional<z.ZodString>;
     exitCode: z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodLiteral<1>]>;
     error: z.ZodOptional<z.ZodString>;
+    outcome: z.ZodObject<{
+        command: z.ZodString;
+        exitMode: z.ZodEnum<{
+            success: "success";
+            success_with_warnings: "success_with_warnings";
+            failed: "failed";
+            timeout: "timeout";
+            cancelled: "cancelled";
+        }>;
+        startedAt: z.ZodString;
+        endedAt: z.ZodString;
+        durationMs: z.ZodNumber;
+        phases: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodString;
+            status: z.ZodEnum<{
+                failed: "failed";
+                timeout: "timeout";
+                cancelled: "cancelled";
+                pending: "pending";
+                running: "running";
+                passed: "passed";
+                warning: "warning";
+                skipped: "skipped";
+            }>;
+            startedAt: z.ZodOptional<z.ZodString>;
+            endedAt: z.ZodOptional<z.ZodString>;
+            durationMs: z.ZodOptional<z.ZodNumber>;
+            timeoutMs: z.ZodOptional<z.ZodNumber>;
+            warningCount: z.ZodOptional<z.ZodNumber>;
+            error: z.ZodOptional<z.ZodObject<{
+                code: z.ZodString;
+                message: z.ZodString;
+                statusCode: z.ZodOptional<z.ZodNumber>;
+                retryable: z.ZodBoolean;
+                retryAfterMs: z.ZodOptional<z.ZodNumber>;
+                phase: z.ZodOptional<z.ZodString>;
+                details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            }, z.core.$strict>>;
+            warnings: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                code: z.ZodString;
+                message: z.ZodString;
+                phase: z.ZodString;
+                details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            }, z.core.$strict>>>;
+            metrics: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+        }, z.core.$strict>>;
+        warnings: z.ZodArray<z.ZodObject<{
+            code: z.ZodString;
+            message: z.ZodString;
+            phase: z.ZodString;
+            details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strict>>;
+        errors: z.ZodArray<z.ZodObject<{
+            code: z.ZodString;
+            message: z.ZodString;
+            statusCode: z.ZodOptional<z.ZodNumber>;
+            retryable: z.ZodBoolean;
+            retryAfterMs: z.ZodOptional<z.ZodNumber>;
+            phase: z.ZodOptional<z.ZodString>;
+            details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strict>>;
+        summary: z.ZodObject<{
+            passed: z.ZodNumber;
+            warnings: z.ZodNumber;
+            failed: z.ZodNumber;
+            skipped: z.ZodNumber;
+            timedOut: z.ZodNumber;
+        }, z.core.$strict>;
+        nextActions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>;
 }, z.core.$strict>;
 export type DbSyncOutput = z.infer<typeof DbSyncOutputSchema>;
 /**
@@ -152,6 +229,7 @@ export declare const DbSyncMachineInputSchema: z.ZodObject<{
     verbose: z.ZodOptional<z.ZodBoolean>;
     skipCodegen: z.ZodOptional<z.ZodBoolean>;
     strictIntrospect: z.ZodOptional<z.ZodBoolean>;
+    strict: z.ZodOptional<z.ZodBoolean>;
     targetDir: z.ZodOptional<z.ZodString>;
     fromProduction: z.ZodOptional<z.ZodBoolean>;
     autoSnapshot: z.ZodOptional<z.ZodBoolean>;
@@ -159,6 +237,8 @@ export declare const DbSyncMachineInputSchema: z.ZodObject<{
     reportJson: z.ZodOptional<z.ZodString>;
     reconcile: z.ZodOptional<z.ZodBoolean>;
     timeoutMs: z.ZodOptional<z.ZodNumber>;
+    snapshotTimeoutMs: z.ZodOptional<z.ZodNumber>;
+    syncTimeoutMs: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strict>;
 export type DbSyncMachineInput = z.infer<typeof DbSyncMachineInputSchema>;
 //# sourceMappingURL=contract.d.ts.map

package/dist/commands/db/sync/machine.d.ts

@@ -104,7 +104,7 @@ export declare const dbSyncMachine: import("xstate").StateMachine<DbSyncContext,
     src: "writeReport";
     logic: import("xstate").PromiseActorLogic<actors.ReportOutput, actors.ReportInput, import("xstate").EventObject>;
     id: string | undefined;
-}, never, never, never, "done" | "failed" | "sync" | "setup" | "idle" | "snapshot" | "preflight" | "reconcile" | "report", string, {
+}, never, never, never, "done" | "failed" | "sync" | "setup" | "idle" | "snapshot" | "report" | "preflight" | "reconcile", string, {
     env?: "local" | "preview" | "production" | undefined;
     check?: boolean | undefined;
     force?: boolean | undefined;
@@ -112,6 +112,7 @@ export declare const dbSyncMachine: import("xstate").StateMachine<DbSyncContext,
     verbose?: boolean | undefined;
     skipCodegen?: boolean | undefined;
     strictIntrospect?: boolean | undefined;
+    strict?: boolean | undefined;
     targetDir?: string | undefined;
     fromProduction?: boolean | undefined;
     autoSnapshot?: boolean | undefined;
@@ -119,6 +120,8 @@ export declare const dbSyncMachine: import("xstate").StateMachine<DbSyncContext,
     reportJson?: string | undefined;
     reconcile?: boolean | undefined;
     timeoutMs?: number | undefined;
+    snapshotTimeoutMs?: number | undefined;
+    syncTimeoutMs?: number | undefined;
 }, {
     env: "local" | "preview" | "production";
     check: boolean;
@@ -128,6 +131,62 @@ export declare const dbSyncMachine: import("xstate").StateMachine<DbSyncContext,
     applied: boolean;
     stepsCompleted: string[];
     exitCode: 0 | 1;
+    outcome: {
+        command: string;
+        exitMode: "success" | "timeout" | "failed" | "cancelled" | "success_with_warnings";
+        startedAt: string;
+        endedAt: string;
+        durationMs: number;
+        phases: {
+            id: string;
+            label: string;
+            status: "timeout" | "warning" | "skipped" | "failed" | "pending" | "running" | "passed" | "cancelled";
+            startedAt?: string | undefined;
+            endedAt?: string | undefined;
+            durationMs?: number | undefined;
+            timeoutMs?: number | undefined;
+            warningCount?: number | undefined;
+            error?: {
+                code: string;
+                message: string;
+                retryable: boolean;
+                statusCode?: number | undefined;
+                retryAfterMs?: number | undefined;
+                phase?: string | undefined;
+                details?: Record<string, unknown> | undefined;
+            } | undefined;
+            warnings?: {
+                code: string;
+                message: string;
+                phase: string;
+                details?: Record<string, unknown> | undefined;
+            }[] | undefined;
+            metrics?: Record<string, number> | undefined;
+        }[];
+        warnings: {
+            code: string;
+            message: string;
+            phase: string;
+            details?: Record<string, unknown> | undefined;
+        }[];
+        errors: {
+            code: string;
+            message: string;
+            retryable: boolean;
+            statusCode?: number | undefined;
+            retryAfterMs?: number | undefined;
+            phase?: string | undefined;
+            details?: Record<string, unknown> | undefined;
+        }[];
+        summary: {
+            passed: number;
+            warnings: number;
+            failed: number;
+            skipped: number;
+            timedOut: number;
+        };
+        nextActions?: string[] | undefined;
+    };
     reportJsonPath?: string | undefined;
     error?: string | undefined;
 }, import("xstate").EventObject, import("xstate").MetaObject, {

package/dist/commands/db/types.d.ts

@@ -79,6 +79,7 @@ export interface DbCommandOptions {
     skipCodegen?: boolean;
     /** Fail when generated schema still contains unresolved unknown(...) columns */
     strictIntrospect?: boolean;
+    strict?: boolean;
     json?: boolean;
     sql?: boolean;
     format?: string;
@@ -99,6 +100,10 @@ export interface DbCommandOptions {
     skip?: boolean;
     /** Subprocess timeout in milliseconds for db sync */
     timeout?: number;
+    /** Snapshot phase timeout in milliseconds */
+    snapshotTimeoutMs?: number;
+    /** Sync phase timeout in milliseconds */
+    syncTimeoutMs?: number;
 }
 /**
  * Seed validation result

package/dist/commands/db/utils/boundary-policy/rule-compiler.d.ts

@@ -4,8 +4,9 @@
  * Purpose: Convert raw policy JSON arrays into typed allowlist rules
  * and normalize a full policy object with fallback defaults.
  */
-import type { BoundaryPolicy, BoundaryPolicyMeta, DeclarativeRiskAllowlistRule, DirectoryPlacementAllowlistRule, PolicyIssueFormatter } from './types.js';
+import type { BoundaryPolicy, BoundaryPolicyMeta, DeclarativeClosureWarningAllowlistRule, DeclarativeRiskAllowlistRule, DirectoryPlacementAllowlistRule, PolicyIssueFormatter } from './types.js';
 export declare function toDeclarativeRiskRules(rawList: unknown, issueFormatter: PolicyIssueFormatter): DeclarativeRiskAllowlistRule[];
 export declare function toDirectoryPlacementRules(rawList: unknown, issueFormatter: PolicyIssueFormatter): DirectoryPlacementAllowlistRule[];
+export declare function toDeclarativeClosureWarningRules(rawList: unknown, issueFormatter: PolicyIssueFormatter): DeclarativeClosureWarningAllowlistRule[];
 export declare function normalizePolicySource(raw: unknown, source: BoundaryPolicyMeta['source'], sourcePath: string, issueFormatter: PolicyIssueFormatter): BoundaryPolicy;
 //# sourceMappingURL=rule-compiler.d.ts.map

package/dist/commands/db/utils/boundary-policy/types.d.ts

@@ -4,6 +4,8 @@
  * Purpose: Shared types for boundary-policy validation, compilation, and loading.
  */
 export type BoundaryPolicyRiskLevel = 'high' | 'medium' | 'low';
+export type DeclarativeClosureWarningCode = 'UNQUALIFIED_CUSTOM_FUNCTION_CALL' | 'DYNAMIC_SQL_EXECUTE';
+export type DeclarativeClosureWarningLevel = 'high' | 'medium';
 export type AllowlistMetadata = {
     owner?: string;
     ticket?: string;
@@ -34,6 +36,20 @@ export type DirectoryPlacementAllowlistRule = {
     expiresAt?: string;
     active: boolean;
 };
+export type DeclarativeClosureWarningAllowlistRule = {
+    id: string;
+    code: DeclarativeClosureWarningCode;
+    filePattern: RegExp;
+    anchorPattern?: RegExp;
+    lineStart: number;
+    lineEnd: number;
+    level?: DeclarativeClosureWarningLevel;
+    reason: string;
+    owner?: string;
+    ticket?: string;
+    expiresAt?: string;
+    active: boolean;
+};
 export type BoundaryPolicyRaw = {
     version?: unknown;
     description?: unknown;
@@ -42,10 +58,13 @@ export type BoundaryPolicyRaw = {
     idempotentPreferredObjects?: unknown;
     declarativeRiskAllowlist?: unknown;
     directoryPlacementAllowlist?: unknown;
+    declarativeClosureWarningAllowlist?: unknown;
 };
 export type RawRule = {
     id?: unknown;
+    code?: unknown;
     filePattern?: unknown;
+    anchorPattern?: unknown;
     descriptionPattern?: unknown;
     messagePattern?: unknown;
     level?: unknown;
@@ -74,6 +93,7 @@ export type BoundaryPolicy = {
     idempotentPreferredObjects: Set<string>;
     declarativeRiskAllowlist: DeclarativeRiskAllowlistRule[];
     directoryPlacementAllowlist: DirectoryPlacementAllowlistRule[];
+    declarativeClosureWarningAllowlist: DeclarativeClosureWarningAllowlistRule[];
     __meta: BoundaryPolicyMeta;
 };
 export type PolicyValidationSeverity = 'warning' | 'error';
@@ -93,6 +113,7 @@ export declare const FALLBACK_DECLARATIVE_OBJECTS: Set<string>;
 export declare const FALLBACK_IDEMPOTENT_OBJECTS: Set<string>;
 export declare const FALLBACK_DECLARATIVE_RISK_ALLOWLIST: DeclarativeRiskAllowlistRule[];
 export declare const FALLBACK_DIRECTORY_PLACEMENT_ALLOWLIST: DirectoryPlacementAllowlistRule[];
+export declare const FALLBACK_DECLARATIVE_CLOSURE_WARNING_ALLOWLIST: DeclarativeClosureWarningAllowlistRule[];
 export declare function isObject(value: unknown): value is Record<string, unknown>;
 export declare function isStringArray(value: unknown): value is string[];
 export declare function isPastDate(value: string, today: string): boolean;

package/dist/commands/db/utils/boundary-policy-runtime.d.ts

@@ -1,4 +1,4 @@
-import { loadBoundaryPolicy, type DeclarativeRiskAllowlistRule, type DirectoryPlacementAllowlistRule } from './boundary-policy.js';
+import { loadBoundaryPolicy, type DeclarativeClosureWarningAllowlistRule, type DeclarativeRiskAllowlistRule, type DirectoryPlacementAllowlistRule } from './boundary-policy.js';
 type Logger = {
     warn: (message: string) => void;
     info: (message: string) => void;
@@ -15,14 +15,23 @@ type DirectoryRiskLike = {
     message: string;
     line?: number;
 };
+type DeclarativeClosureWarningLike = {
+    code: DeclarativeClosureWarningAllowlistRule['code'];
+    level: 'high' | 'medium';
+    file: string;
+    line: number;
+};
 export declare function getBoundaryPolicy(cwd?: string): BoundaryPolicy;
 export declare function reportBoundaryPolicyState(logger: Logger, policy: BoundaryPolicy): void;
 export declare function assertBoundaryPolicyUsable(logger: Logger, policy: BoundaryPolicy): void;
 export declare function assertBoundaryPolicyQualityGate(logger: Logger, policy: BoundaryPolicy, strict: boolean): void;
 export declare function findDeclarativeRiskAllowlistMatch(risk: DeclarativeRiskLike, policy: BoundaryPolicy): DeclarativeRiskAllowlistRule | undefined;
-export declare function hasExplicitLineScope(rule: DirectoryPlacementAllowlistRule): boolean;
-export declare function entryLineScopeMatches(issueLine: number | undefined, rule: DirectoryPlacementAllowlistRule): boolean;
+export declare function hasExplicitLineScope(rule: DirectoryPlacementAllowlistRule | Pick<DeclarativeClosureWarningAllowlistRule, 'lineStart' | 'lineEnd'>): boolean;
+export declare function entryLineScopeMatches(issueLine: number | undefined, rule: DirectoryPlacementAllowlistRule | Pick<DeclarativeClosureWarningAllowlistRule, 'lineStart' | 'lineEnd'>): boolean;
 export declare function findDirectoryPlacementAllowlistMatch(issue: DirectoryRiskLike, policy: BoundaryPolicy): DirectoryPlacementAllowlistRule | undefined;
+export declare function findDeclarativeClosureWarningAllowlistMatch(warning: DeclarativeClosureWarningLike, policy: BoundaryPolicy, options?: {
+    cwd?: string;
+}): DeclarativeClosureWarningAllowlistRule | undefined;
 export declare function resolveProductionApplyStrictMode(policy: BoundaryPolicy, strictOption: boolean | undefined): boolean;
 export {};
 //# sourceMappingURL=boundary-policy-runtime.d.ts.map

package/dist/commands/db/utils/boundary-policy.d.ts

@@ -1,5 +1,5 @@
 import type { BoundaryPolicy } from './boundary-policy/types.js';
-export type { BoundaryPolicy, BoundaryPolicyMeta, BoundaryPolicyRiskLevel, DeclarativeRiskAllowlistRule, DirectoryPlacementAllowlistRule, } from './boundary-policy/types.js';
+export type { BoundaryPolicy, BoundaryPolicyMeta, BoundaryPolicyRiskLevel, DeclarativeClosureWarningAllowlistRule, DeclarativeClosureWarningCode, DeclarativeRiskAllowlistRule, DirectoryPlacementAllowlistRule, } from './boundary-policy/types.js';
 export { formatAllowlistMetadata } from './boundary-policy/types.js';
 export declare function loadBoundaryPolicy(projectRoot: string, policyPath?: string): BoundaryPolicy;
 //# sourceMappingURL=boundary-policy.d.ts.map

package/dist/commands/db/utils/db-target.d.ts

@@ -10,10 +10,10 @@
  * PRD Naming Convention:
  * - DATABASE_URL: drizzle_app (App runtime, DML only)
  * - DATABASE_URL_ADMIN: postgres (Migrations, Drizzle Kit)
- * - GH_DATABASE_URL: drizzle_app (CI: Production app)
  * - GH_DATABASE_URL_ADMIN: postgres (CI: Production migrations)
  */
 export type RunaDbEnv = 'local' | 'preview' | 'main' | 'production';
+export type ResolvedDatabaseUrlSource = 'DATABASE_URL_ADMIN' | 'DATABASE_URL' | 'GH_DATABASE_URL_ADMIN' | 'LOCAL_SUPABASE';
 /**
  * Resolve database URL for a given environment (DDL operations).
  *
@@ -35,13 +35,15 @@ export type RunaDbEnv = 'local' | 'preview' | 'main' | 'production';
  * ### Production/Main environment:
  * 1. GH_DATABASE_URL_ADMIN (CI: postgres role, DDL capable)
  * 2. DATABASE_URL_ADMIN (non-CI: postgres role, DDL capable)
- * 3. GH_DATABASE_URL (CI fallback)
- * 4. DATABASE_URL (last resort fallback)
  *
  * @param environment - Target environment
  * @returns Database URL string
  * @throws CLIError if no URL found for preview/production
  */
+export declare function resolveDatabaseTarget(environment: RunaDbEnv): {
+    url: string;
+    source: ResolvedDatabaseUrlSource;
+};
 export declare function resolveDatabaseUrl(environment: RunaDbEnv): string;
 /**
  * Try to resolve database URL without throwing.

package/dist/commands/db/utils/declarative-dependency-collectors.d.ts

@@ -0,0 +1,6 @@
+import type { DeclarativeDependencyWarning } from './declarative-dependency-contract.js';
+import { type FunctionDefinition, type FunctionReference } from './declarative-dependency-sql-utils.js';
+export declare function collectReferencesForStatement(statement: string, file: string, line: number): FunctionReference[];
+export declare function collectCustomFunctionNames(definitions: FunctionDefinition[]): Set<string>;
+export declare function collectWarningsForStatement(statement: string, file: string, line: number, knownFunctionNames: Set<string>): DeclarativeDependencyWarning[];
+//# sourceMappingURL=declarative-dependency-collectors.d.ts.map

package/dist/commands/db/utils/declarative-dependency-contract.d.ts

@@ -0,0 +1,78 @@
+/**
+ * AI HINT: Declarative dependency contract analysis
+ *
+ * Purpose: Analyze declarative SQL for function dependency closure violations
+ * and warnings. Ensures declarative desired-state SQL only references functions
+ * defined within declarative scope.
+ *
+ * Submodules:
+ *   declarative-dependency-sql-utils.ts   — SQL text processing + function extraction
+ *   declarative-dependency-collectors.ts  — Reference and warning collection
+ */
+import type { DeclarativeClosureWarningCode, DeclarativeClosureWarningLevel } from './boundary-policy/types.js';
+import { type FunctionDefinition, type FunctionReference, type ReferenceSource, type SqlFile, type SqlLayer } from './declarative-dependency-sql-utils.js';
+export type { FunctionDefinition, FunctionReference, SqlLayer, ReferenceSource, } from './declarative-dependency-sql-utils.js';
+export interface DeclarativeDependencyViolation {
+    code: 'DECLARATIVE_IDEMPOTENT_ONLY_FUNCTION' | 'DECLARATIVE_UNKNOWN_MANAGED_FUNCTION' | 'DECLARATIVE_PUBLIC_UNKNOWN_FUNCTION';
+    file: string;
+    line: number;
+    qualifiedName: string;
+    source: ReferenceSource;
+    message: string;
+    suggestion: string;
+    definedIn?: {
+        file: string;
+        line: number;
+        layer: SqlLayer;
+    };
+}
+export interface DeclarativeDependencyWarning {
+    code: DeclarativeClosureWarningCode;
+    level: DeclarativeClosureWarningLevel;
+    file: string;
+    line: number;
+    source: ReferenceSource;
+    message: string;
+    suggestion: string;
+}
+export interface DeclarativeDependencyAnalysisResult {
+    contractNote: string;
+    managedSchemas: string[];
+    violations: DeclarativeDependencyViolation[];
+    warnings: DeclarativeDependencyWarning[];
+    references: FunctionReference[];
+    definitions: {
+        declarative: FunctionDefinition[];
+        idempotent: FunctionDefinition[];
+    };
+}
+export interface FormattedDeclarativeDependencyViolation {
+    summary: string;
+    callee: string;
+    definedIn?: string;
+    suggestion: string;
+}
+export interface FormattedDeclarativeDependencyWarning {
+    summary: string;
+    suggestion: string;
+}
+export interface DeclarativeDependencyWarningSummary {
+    code: DeclarativeDependencyWarning['code'];
+    count: number;
+    label: string;
+}
+export declare const DECLARATIVE_CONTRACT_NOTE = "Declarative desired-state build ignores idempotent-only helpers from supabase/schemas/idempotent/*.sql.";
+export declare const DB_APPLY_CHECK_MODE_CONTRACT_NOTE = "Check mode ignores idempotent-only helpers when building declarative desired state.";
+export declare const MAX_DETAILED_DECLARATIVE_WARNINGS = 10;
+declare function collectDefinitions(files: SqlFile[], layer: SqlLayer): FunctionDefinition[];
+declare function collectDeclarativeReferences(files: SqlFile[]): FunctionReference[];
+export declare function analyzeDeclarativeDependencyContract(targetDir?: string): DeclarativeDependencyAnalysisResult;
+export declare function formatDeclarativeDependencyViolation(violation: DeclarativeDependencyViolation): FormattedDeclarativeDependencyViolation;
+export declare function formatDeclarativeDependencyWarning(warning: DeclarativeDependencyWarning): FormattedDeclarativeDependencyWarning;
+export declare function summarizeDeclarativeDependencyWarnings(warnings: DeclarativeDependencyWarning[]): DeclarativeDependencyWarningSummary[];
+export { extractFirstDollarBody as _extractFirstDollarBody } from './declarative-dependency-sql-utils.js';
+export { collectReferencesForStatement as _collectReferencesForStatement } from './declarative-dependency-collectors.js';
+export { collectWarningsForStatement as _collectWarningsForStatement } from './declarative-dependency-collectors.js';
+export declare const _collectDefinitions: typeof collectDefinitions;
+export declare const _collectDeclarativeReferences: typeof collectDeclarativeReferences;
+//# sourceMappingURL=declarative-dependency-contract.d.ts.map

package/dist/commands/db/utils/declarative-dependency-sql-utils.d.ts

@@ -0,0 +1,49 @@
+export type SqlLayer = 'declarative' | 'idempotent';
+export type ReferenceSource = 'statement' | 'function-body' | 'do-body';
+export interface FunctionDefinition {
+    qualifiedName: string;
+    schema: string;
+    name: string;
+    file: string;
+    line: number;
+    layer: SqlLayer;
+}
+export interface FunctionReference {
+    qualifiedName: string;
+    schema: string;
+    name: string;
+    file: string;
+    line: number;
+    source: ReferenceSource;
+}
+export type SqlFile = {
+    absolutePath: string;
+    relativePath: string;
+    content: string;
+};
+export type ExtractedBody = {
+    body: string;
+    startLine: number;
+};
+export declare const FUNCTION_DEFINITION_RE: RegExp;
+export declare const QUALIFIED_FUNCTION_CALL_RE: RegExp;
+export declare const EXECUTE_FUNCTION_RE: RegExp;
+export declare const UNQUALIFIED_FUNCTION_CALL_RE: RegExp;
+export declare const DEFAULT_UNQUALIFIED_CALL_RE: RegExp;
+export declare const CHECK_UNQUALIFIED_CALL_RE: RegExp;
+export declare const DYNAMIC_SQL_EXECUTE_RE: RegExp;
+export declare const STATIC_EXECUTE_LITERAL_RE: RegExp;
+export declare const DOLLAR_TAG_RE: RegExp;
+export declare const PUBLIC_SCHEMA = "public";
+export declare function countNewlines(text: string): number;
+export declare function collectSqlFiles(targetDir: string, layer: SqlLayer): SqlFile[];
+export declare function blankQuotedStrings(content: string): string;
+export declare function sanitizeTopLevelSql(statement: string): string;
+export declare function sanitizeExecutableCode(content: string): string;
+export declare function sanitizeExecutableCodePreserveStrings(content: string): string;
+export declare function extractManagedSchemas(files: SqlFile[]): Set<string>;
+export declare function extractDefinitionFromStatement(statement: string, file: string, line: number, layer: SqlLayer): FunctionDefinition | null;
+export declare function extractFirstDollarBody(statement: string, baseLine: number): ExtractedBody | null;
+export declare function shouldIgnoreQualifiedFunctionCall(prefix: string): boolean;
+export declare function decodeSqlStringLiteral(literal: string): string | null;
+//# sourceMappingURL=declarative-dependency-sql-utils.d.ts.map

package/dist/commands/db/utils/declarative-dependency-warning-governance.d.ts

@@ -0,0 +1,24 @@
+import type { createCLILogger } from '@runa-ai/runa';
+import { type DeclarativeClosureWarningAllowlistRule } from './boundary-policy.js';
+import { type DeclarativeDependencyWarning } from './declarative-dependency-contract.js';
+type Logger = Pick<ReturnType<typeof createCLILogger>, 'info' | 'warn'>;
+export interface ReviewedDeclarativeDependencyWarning {
+    warning: DeclarativeDependencyWarning;
+    rule: DeclarativeClosureWarningAllowlistRule;
+}
+export interface DeclarativeDependencyWarningReview {
+    strict: boolean;
+    allowlistReportEnabled: boolean;
+    allowlistedWarnings: ReviewedDeclarativeDependencyWarning[];
+    unreviewedWarnings: DeclarativeDependencyWarning[];
+}
+export declare function reviewDeclarativeDependencyWarnings(params: {
+    cwd?: string;
+    logger: Logger;
+    warnings: DeclarativeDependencyWarning[];
+    strictOption?: boolean;
+}): DeclarativeDependencyWarningReview;
+export declare function logDeclarativeDependencyWarnings(logger: Logger, review: DeclarativeDependencyWarningReview): void;
+export declare function buildDeclarativeDependencyWarningFailureLines(review: DeclarativeDependencyWarningReview): string[];
+export {};
+//# sourceMappingURL=declarative-dependency-warning-governance.d.ts.map

package/dist/commands/db/utils/preflight-check.d.ts

@@ -30,5 +30,5 @@ export declare class StepCounter {
 /**
  * Run all preflight checks
  */
-export declare function runPreflightChecks(env: string): Promise<PreflightCheckResult>;
+export declare function runPreflightChecks(env: string, strict?: boolean): Promise<PreflightCheckResult>;
 //# sourceMappingURL=preflight-check.d.ts.map

package/dist/commands/db/utils/preflight-checks/declarative-dependency-checks.d.ts

@@ -0,0 +1,4 @@
+import type { createCLILogger } from '@runa-ai/runa';
+import type { PreflightCheckResult, StepCounter } from '../preflight-check.js';
+export declare function runDeclarativeDependencyCheck(result: PreflightCheckResult, logger: ReturnType<typeof createCLILogger>, step: StepCounter, strictOption?: boolean): Promise<void>;
+//# sourceMappingURL=declarative-dependency-checks.d.ts.map

package/dist/commands/db/utils/preflight-checks/idempotent-risk-checks.d.ts

@@ -0,0 +1,4 @@
+import type { createCLILogger } from '@runa-ai/runa';
+import type { PreflightCheckResult, StepCounter } from '../preflight-check.js';
+export declare function runIdempotentSchemaRiskCheck(result: PreflightCheckResult, logger: ReturnType<typeof createCLILogger>, step: StepCounter, strictOption?: boolean): Promise<void>;
+//# sourceMappingURL=idempotent-risk-checks.d.ts.map

package/dist/commands/db/utils/preflight-checks/schema-boundary-checks.d.ts

@@ -0,0 +1,4 @@
+import type { createCLILogger } from '@runa-ai/runa';
+import type { PreflightCheckResult, StepCounter } from '../preflight-check.js';
+export declare function runSchemaBoundaryPlacementCheck(result: PreflightCheckResult, logger: ReturnType<typeof createCLILogger>, step: StepCounter, strictOption?: boolean): Promise<void>;
+//# sourceMappingURL=schema-boundary-checks.d.ts.map

package/dist/commands/db/utils/preflight-checks/schema-risk-policy.d.ts

@@ -0,0 +1,4 @@
+import type { RiskLevel, SchemaRisk } from '../../../../validators/risk-detector.js';
+export declare function correctSyncPreflightRiskLevel(originalLevel: RiskLevel, reasonCode: string | undefined): RiskLevel;
+export declare function applySyncPreflightRiskPolicy<T extends SchemaRisk>(risks: T[]): T[];
+//# sourceMappingURL=schema-risk-policy.d.ts.map

package/dist/commands/db/utils/preflight-checks/supabase-checks.d.ts

@@ -17,6 +17,18 @@ export declare function isSupabaseStatusRunning(output: {
     stdout: string;
     stderr: string;
 }): boolean;
+export declare function classifySupabaseHealth(input: {
+    statusRunning: boolean;
+    dbConnected: boolean;
+}): {
+    kind: 'ok';
+} | {
+    kind: 'status-inconclusive-db-ready';
+} | {
+    kind: 'db-unreachable';
+} | {
+    kind: 'not-running';
+};
 /**
  * Check if Supabase is running (local only)
  */

package/dist/commands/db/utils/psql.d.ts

@@ -57,6 +57,8 @@ export declare function psqlSyncFile(params: {
     databaseUrl: string;
     filePath: string;
     onErrorStop?: boolean;
+    /** Timeout in milliseconds (default: 5 minutes). */
+    timeout?: number;
 }): {
     status: number | null;
     stdout: string;
@@ -71,4 +73,25 @@ export declare function psqlExec(params: {
     databaseUrl: string;
     sql: string;
 }): Promise<void>;
+/**
+ * Execute multiple SQL statements in a single psql process via a temp file.
+ *
+ * Reduces connection count from N (one per statement) to 1.
+ * Uses ON_ERROR_STOP=off by default so individual statement failures
+ * don't block subsequent statements (matches non-fatal usage patterns).
+ *
+ * @param params - Batch execution parameters
+ * @returns Result with status, stdout, stderr
+ */
+export declare function psqlSyncBatch(params: {
+    databaseUrl: string;
+    statements: string[];
+    onErrorStop?: boolean;
+    /** Timeout in milliseconds (default: 60 seconds). */
+    timeout?: number;
+}): {
+    status: number | null;
+    stdout: string;
+    stderr: string;
+};
 //# sourceMappingURL=psql.d.ts.map