@runa-ai/runa-cli 0.7.1 → 0.7.2

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

package/dist/commands/db/utils/sql-table-extractor.d.ts

@@ -22,7 +22,48 @@
  * For full SQL parsing, use pg_catalog queries (see introspectColumns).
  */
 import type { ForeignKeyDefinition, TableEntry } from '@runa-ai/runa/manifests';
-type SqlParserUtils = Awaited<ReturnType<typeof import('@runa-ai/runa/ast').loadSqlParserUtils>>;
+interface SqlParserUtils {
+    isSqlParserAvailable(): Promise<boolean>;
+    parseSchemaDocument(sqlContent: string): Promise<{
+        tables: Array<{
+            schema: string;
+            name: string;
+            qualifiedName: string;
+            lineNumber?: number;
+            columns: Array<{
+                name: string;
+                type: string;
+                notNull: boolean;
+                hasDefault: boolean;
+                isPrimaryKey: boolean;
+            }>;
+            primaryKey?: string[];
+            foreignKeys: Array<{
+                column: string;
+                referencesTable: string;
+                referencesColumn: string;
+                onDelete?: 'CASCADE' | 'SET NULL' | 'SET DEFAULT' | 'RESTRICT' | 'NO ACTION';
+                onUpdate?: 'CASCADE' | 'SET NULL' | 'SET DEFAULT' | 'RESTRICT' | 'NO ACTION';
+            }>;
+            indexes: Array<{
+                name: string;
+                columns: string[];
+                isUnique: boolean;
+            }>;
+        }>;
+        policies: Array<{
+            schema: string;
+            table: string;
+            name: string;
+            for: 'select' | 'insert' | 'update' | 'delete' | 'all';
+            using?: string;
+            withCheck?: string;
+        }>;
+    }>;
+    parseCreateTables(sqlContent: string): Promise<unknown>;
+    parseIndexesForTables(sqlContent: string, tables: unknown[]): Promise<void>;
+    parseCreatePolicies(sqlContent: string): Promise<unknown>;
+}
 /**
  * Get SQL parser utilities (requires AST to be available)
  */

package/dist/commands/env/commands/setup/types.d.ts

@@ -43,6 +43,7 @@ export interface VercelProjectInfo {
 export interface SupabaseProjectInfo {
     projectRef: string;
     projectName: string;
+    region: string;
     anonKey: string;
     serviceRoleKey: string;
     supabaseUrl: string;

package/dist/commands/env/constants/local-supabase.d.ts

@@ -17,6 +17,9 @@ export interface SupabaseConfig {
     db: number;
     studio: number;
 }
+export interface DetectLocalSupabasePortsOptions {
+    skipStatusDetection?: boolean;
+}
 /** @internal Exported for testing */
 export declare function parseTomlPort(content: string, section: string, key: string): number | null;
 /**
@@ -28,7 +31,7 @@ export declare function parseTomlPort(content: string, section: string, key: str
  * 3. `supabase/config.toml` [api].port and [db].port
  * 4. defaults
  */
-export declare function detectLocalSupabasePorts(projectRoot?: string): SupabaseConfig;
+export declare function detectLocalSupabasePorts(projectRoot?: string, options?: DetectLocalSupabasePortsOptions): SupabaseConfig;
 /** @internal Exported for tests */
 export declare function clearLocalSupabaseDetectionCache(): void;
 /**

package/dist/commands/observability.d.ts

@@ -0,0 +1,72 @@
+import { Command } from 'commander';
+import { z } from 'zod';
+export declare const ObservabilityStatusInputSchema: z.ZodObject<{
+    cwd: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const ObservabilityStatusOutputSchema: z.ZodObject<{
+    ready: z.ZodBoolean;
+    targetDir: z.ZodString;
+    checks: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        status: z.ZodEnum<{
+            ok: "ok";
+            error: "error";
+            warning: "warning";
+        }>;
+        message: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const ObservabilityEnableInputSchema: z.ZodObject<{
+    cwd: z.ZodOptional<z.ZodString>;
+    check: z.ZodOptional<z.ZodBoolean>;
+    skipFunctionDeploy: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>;
+export declare const ObservabilityEnableOutputSchema: z.ZodObject<{
+    targetDir: z.ZodString;
+    checks: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        status: z.ZodEnum<{
+            ok: "ok";
+            error: "error";
+            warning: "warning";
+        }>;
+        message: z.ZodString;
+    }, z.core.$strip>>;
+    dbSyncApplied: z.ZodBoolean;
+    functionSecretSynced: z.ZodBoolean;
+    functionsDeployed: z.ZodArray<z.ZodString>;
+    skippedFunctions: z.ZodArray<z.ZodString>;
+    linkedProjectDetected: z.ZodBoolean;
+}, z.core.$strip>;
+export declare const ObservabilityEmitTestEventInputSchema: z.ZodObject<{
+    baseUrl: z.ZodOptional<z.ZodString>;
+    accessToken: z.ZodOptional<z.ZodString>;
+    functionSecret: z.ZodOptional<z.ZodString>;
+    scopeKey: z.ZodOptional<z.ZodString>;
+    serviceName: z.ZodOptional<z.ZodString>;
+    environment: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const ObservabilityEmitTestEventOutputSchema: z.ZodObject<{
+    eventId: z.ZodString;
+    issueId: z.ZodNullable<z.ZodString>;
+    resolvedScopeKey: z.ZodString;
+}, z.core.$strip>;
+export declare const ObservabilityDispatchInputSchema: z.ZodObject<{
+    baseUrl: z.ZodOptional<z.ZodString>;
+    accessToken: z.ZodOptional<z.ZodString>;
+    functionSecret: z.ZodOptional<z.ZodString>;
+    limit: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strict>;
+export declare const ObservabilityDispatchOutputSchema: z.ZodObject<{
+    processed: z.ZodNumber;
+    delivered: z.ZodNumber;
+    failed: z.ZodNumber;
+}, z.core.$strip>;
+export declare const observabilityStatusCommand: Command;
+export declare const observabilityCheckCommand: Command;
+export declare const observabilityDoctorCommand: Command;
+export declare const observabilityEnableCommand: Command;
+export declare const observabilityEmitTestEventCommand: Command;
+export declare const observabilityDispatchCommand: Command;
+export declare const observabilityCommand: Command;
+//# sourceMappingURL=observability.d.ts.map

package/dist/commands/observability.helpers.d.ts

@@ -0,0 +1,25 @@
+export interface ObservabilityStatusItem {
+    name: string;
+    status: 'ok' | 'warning' | 'error';
+    message: string;
+}
+interface ObservabilityFunctionSecretSyncMarker {
+    version: 1;
+    projectRef: string;
+    secretHash: string;
+    syncedAt: string;
+}
+export declare function detectSupabaseProjectLink(targetDir: string): boolean;
+export declare function resolveSupabaseProjectRef(targetDir: string): string | null;
+export declare function hashObservabilityFunctionSecret(secret: string): string;
+export declare function readObservabilityFunctionSecretSyncMarker(targetDir: string): ObservabilityFunctionSecretSyncMarker | null;
+export declare function writeObservabilityFunctionSecretSyncMarker(targetDir: string, input: {
+    projectRef: string;
+    secret: string;
+}): void;
+export declare function buildObservabilityChecks(targetDir: string): ObservabilityStatusItem[];
+export declare function isBlockingObservabilityCheck(check: ObservabilityStatusItem): boolean;
+export declare function getObservabilityEnableBlockingChecks(targetDir: string, checks: ObservabilityStatusItem[]): ObservabilityStatusItem[];
+export declare function isObservabilityReady(checks: ObservabilityStatusItem[]): boolean;
+export {};
+//# sourceMappingURL=observability.helpers.d.ts.map

package/dist/commands/template-check/contract.d.ts

@@ -55,12 +55,12 @@ export declare const FileCategorySchema: z.ZodEnum<{
     rules: "rules";
     workflows: "workflows";
     config: "config";
+    other: "other";
     agents: "agents";
     skills: "skills";
     commands: "commands";
     prompts: "prompts";
     "root-docs": "root-docs";
-    other: "other";
 }>;
 export type FileCategory = z.infer<typeof FileCategorySchema>;
 /**
@@ -74,12 +74,12 @@ export declare const ComparisonResultSchema: z.ZodObject<{
         rules: "rules";
         workflows: "workflows";
         config: "config";
+        other: "other";
         agents: "agents";
         skills: "skills";
         commands: "commands";
         prompts: "prompts";
         "root-docs": "root-docs";
-        other: "other";
     }>;
     status: z.ZodEnum<{
         diff: "diff";
@@ -128,12 +128,12 @@ export declare const SyncCheckOutputSchema: z.ZodObject<{
             rules: "rules";
             workflows: "workflows";
             config: "config";
+            other: "other";
             agents: "agents";
             skills: "skills";
             commands: "commands";
             prompts: "prompts";
             "root-docs": "root-docs";
-            other: "other";
         }>;
         status: z.ZodEnum<{
             diff: "diff";

package/dist/commands/template-check/machine.d.ts

@@ -46,7 +46,7 @@ export declare const syncCheckMachine: import("xstate").StateMachine<SyncCheckCo
     results: {
         runaPath: string | null;
         templatePath: string | null;
-        category: "database" | "rules" | "workflows" | "config" | "agents" | "skills" | "commands" | "prompts" | "root-docs" | "other";
+        category: "database" | "rules" | "workflows" | "config" | "other" | "agents" | "skills" | "commands" | "prompts" | "root-docs";
         status: "diff" | "identical" | "renamed" | "runa-only" | "template-only" | "expected-runa-only" | "expected-template-only" | "intentionally-different";
         ahead?: "runa" | "template" | "diverged" | "equal" | undefined;
         lineDiff?: string | undefined;

package/dist/commands/workflow/commands/deploy-production.d.ts

@@ -4,7 +4,6 @@ import { Command } from 'commander';
  *
  * PRD Naming Convention:
  * - GH_DATABASE_URL_ADMIN = postgres role (DDL capable, for schema deployment)
- * - GH_DATABASE_URL = drizzle_app role (app runtime)
  */
 export declare const deployProductionCommand: Command;
 //# sourceMappingURL=deploy-production.d.ts.map