@runa-ai/runa-cli 0.5.44 → 0.5.46

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

@@ -1 +1 @@
-{"version":3,"file":"machine.d.ts","sourceRoot":"","sources":["../../../../src/commands/ci/machine/machine.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AAEH,OAAO,EAAU,KAAK,YAAY,EAAS,MAAM,QAAQ,CAAC;AA8C1D,OAAO,KAAK,EAAE,SAAS,EAAE,OAAO,EAAqB,MAAM,YAAY,CAAC;AAgBxE,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAitCpB,CAAC;AAMH,MAAM,MAAM,SAAS,GAAG,OAAO,SAAS,CAAC;AACzC,MAAM,MAAM,UAAU,GAAG,YAAY,CAAC,OAAO,SAAS,CAAC,CAAC;AAMxD;;GAEG;AACH,wBAAgB,YAAY,CAAC,QAAQ,EAAE,UAAU,GAAG,MAAM,CAYzD;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,QAAQ,EAAE,UAAU,GAAG,OAAO,CAExD;AAED;;GAEG;AACH,wBAAgB,QAAQ,CAAC,QAAQ,EAAE,UAAU,GAAG,MAAM,GAAG,IAAI,CAE5D;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,QAAQ,EAAE,UAAU,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAE3D"}
+{"version":3,"file":"machine.d.ts","sourceRoot":"","sources":["../../../../src/commands/ci/machine/machine.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AAEH,OAAO,EAAU,KAAK,YAAY,EAAS,MAAM,QAAQ,CAAC;AA8C1D,OAAO,KAAK,EAAE,SAAS,EAAE,OAAO,EAAqB,MAAM,YAAY,CAAC;AAexE,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAymCpB,CAAC;AAMH,MAAM,MAAM,SAAS,GAAG,OAAO,SAAS,CAAC;AACzC,MAAM,MAAM,UAAU,GAAG,YAAY,CAAC,OAAO,SAAS,CAAC,CAAC;AAMxD;;GAEG;AACH,wBAAgB,YAAY,CAAC,QAAQ,EAAE,UAAU,GAAG,MAAM,CAYzD;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,QAAQ,EAAE,UAAU,GAAG,OAAO,CAExD;AAED;;GAEG;AACH,wBAAgB,QAAQ,CAAC,QAAQ,EAAE,UAAU,GAAG,MAAM,GAAG,IAAI,CAE5D;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,QAAQ,EAAE,UAAU,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAE3D"}

package/dist/commands/ci/utils/app-runtime.d.ts

@@ -9,12 +9,22 @@ export declare function writeEnvLocal(params: {
     appDir: string;
     values: Record<string, string>;
 }): Promise<void>;
+/**
+ * App start mode:
+ * - 'dev': Development mode with hot reload (next dev)
+ * - 'start': Production mode (next start, requires build)
+ */
+export type AppMode = 'dev' | 'start';
 export declare function startAppBackground(params: {
     repoRoot: string;
     appDir: string;
     port: number;
     env: NodeJS.ProcessEnv;
     tmpDir: string;
+    /** App mode: 'dev' for development (hot reload), 'start' for production. Default: 'start' */
+    mode?: AppMode;
+    /** Stream output to terminal in addition to log file. Default: false */
+    stream?: boolean;
 }): Promise<{
     pid: number;
     cleanupStreams: () => void;

package/dist/commands/ci/utils/app-runtime.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"app-runtime.d.ts","sourceRoot":"","sources":["../../../../src/commands/ci/utils/app-runtime.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAmGH,wBAAsB,aAAa,CAAC,MAAM,EAAE;IAC1C,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAChC,GAAG,OAAO,CAAC,IAAI,CAAC,CAMhB;AAwJD,wBAAsB,kBAAkB,CAAC,MAAM,EAAE;IAC/C,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC,UAAU,CAAC;IACvB,MAAM,EAAE,MAAM,CAAC;CAChB,GAAG,OAAO,CAAC;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,cAAc,EAAE,MAAM,IAAI,CAAA;CAAE,CAAC,CA0DvD;AAED,wBAAsB,eAAe,CAAC,MAAM,EAAE;IAC5C,IAAI,EAAE,MAAM,CAAC;IACb,cAAc,EAAE,MAAM,CAAC;IACvB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,GAAG,OAAO,CAAC,IAAI,CAAC,CAOhB"}
+{"version":3,"file":"app-runtime.d.ts","sourceRoot":"","sources":["../../../../src/commands/ci/utils/app-runtime.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AA+GH,wBAAsB,aAAa,CAAC,MAAM,EAAE;IAC1C,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAChC,GAAG,OAAO,CAAC,IAAI,CAAC,CAMhB;AAiHD;;;;GAIG;AACH,MAAM,MAAM,OAAO,GAAG,KAAK,GAAG,OAAO,CAAC;AA4DtC,wBAAsB,kBAAkB,CAAC,MAAM,EAAE;IAC/C,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC,UAAU,CAAC;IACvB,MAAM,EAAE,MAAM,CAAC;IACf,6FAA6F;IAC7F,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,wEAAwE;IACxE,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB,GAAG,OAAO,CAAC;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,cAAc,EAAE,MAAM,IAAI,CAAA;CAAE,CAAC,CA+DvD;AAED,wBAAsB,eAAe,CAAC,MAAM,EAAE;IAC5C,IAAI,EAAE,MAAM,CAAC;IACb,cAAc,EAAE,MAAM,CAAC;IACvB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,GAAG,OAAO,CAAC,IAAI,CAAC,CAOhB"}

package/dist/commands/db/utils/import-impact-analyzer.d.ts

@@ -1,5 +1,5 @@
 /**
- * AI HINT: Schema Import Impact Analyzer
+ * AI HINT: Schema Import Impact Analyzer (ts-morph based)
  *
  * Purpose: Analyze which files import schema tables/types and report impact
  * Usage: Used by `runa db sync --show-import-impact` to help developers
@@ -7,9 +7,15 @@
  *
  * Flow:
  * 1. Scan project for TypeScript files
- * 2. Find imports from database/schema packages
+ * 2. Use ts-morph AST to find imports from database/schema packages
  * 3. Map imported symbols to files
  * 4. Report which files would be affected by changes
+ *
+ * Why ts-morph (not regex):
+ * - Correctly handles comments containing 'import' keywords
+ * - Handles multi-line imports
+ * - Handles template literals and nested quotes
+ * - Per .claude/rules/code-quality.md: "Use AST (ts-morph) for TypeScript parsing"
  */
 export interface ImportReference {
     /** File path relative to project root */

package/dist/commands/db/utils/import-impact-analyzer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"import-impact-analyzer.d.ts","sourceRoot":"","sources":["../../../../src/commands/db/utils/import-impact-analyzer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AASH,MAAM,WAAW,eAAe;IAC9B,yCAAyC;IACzC,IAAI,EAAE,MAAM,CAAC;IACb,wCAAwC;IACxC,IAAI,EAAE,MAAM,CAAC;IACb,+BAA+B;IAC/B,MAAM,EAAE,MAAM,CAAC;IACf,gEAAgE;IAChE,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,kBAAkB;IACjC,iDAAiD;IACjD,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE,eAAe,EAAE,CAAC,CAAC;IAC5C,oCAAoC;IACpC,iBAAiB,EAAE,MAAM,CAAC;IAC1B,gCAAgC;IAChC,gBAAgB,EAAE,MAAM,CAAC;CAC1B;AAkJD;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,MAAM,GAAG,kBAAkB,CAuBvE;AAED;;GAEG;AACH,wBAAgB,wBAAwB,CACtC,MAAM,EAAE,kBAAkB,EAC1B,cAAc,CAAC,EAAE,MAAM,EAAE,GACxB,MAAM,EAAE,CAoCV"}
+{"version":3,"file":"import-impact-analyzer.d.ts","sourceRoot":"","sources":["../../../../src/commands/db/utils/import-impact-analyzer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAUH,MAAM,WAAW,eAAe;IAC9B,yCAAyC;IACzC,IAAI,EAAE,MAAM,CAAC;IACb,wCAAwC;IACxC,IAAI,EAAE,MAAM,CAAC;IACb,+BAA+B;IAC/B,MAAM,EAAE,MAAM,CAAC;IACf,gEAAgE;IAChE,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,kBAAkB;IACjC,iDAAiD;IACjD,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE,eAAe,EAAE,CAAC,CAAC;IAC5C,oCAAoC;IACpC,iBAAiB,EAAE,MAAM,CAAC;IAC1B,gCAAgC;IAChC,gBAAgB,EAAE,MAAM,CAAC;CAC1B;AA+JD;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,MAAM,GAAG,kBAAkB,CA8BvE;AAED;;GAEG;AACH,wBAAgB,wBAAwB,CACtC,MAAM,EAAE,kBAAkB,EAC1B,cAAc,CAAC,EAAE,MAAM,EAAE,GACxB,MAAM,EAAE,CAoCV"}

package/dist/commands/db/utils/schema-sync.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schema-sync.d.ts","sourceRoot":"","sources":["../../../../src/commands/db/utils/schema-sync.ts"],"names":[],"mappings":"AA0KA,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB;AAED,MAAM,WAAW,QAAQ;IACvB,cAAc,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAC5B,aAAa,EAAE,GAAG,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC;IAC3C,QAAQ,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IACtB,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC;IAErC,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,mBAAmB,EAAE,KAAK,CAAC;QACzB,IAAI,EAAE,MAAM,CAAC;QACb,QAAQ,EAAE,MAAM,EAAE,CAAC;QACnB,YAAY,EAAE,MAAM,EAAE,CAAC;QACvB,KAAK,EAAE,MAAM,EAAE,CAAC;QAChB,OAAO,EAAE,MAAM,EAAE,CAAC;KACnB,CAAC,CAAC;CACJ;AAMD;;;;;;;;;;;GAWG;AACH,wBAAsB,2BAA2B,CAC/C,aAAa,EAAE,MAAM,EACrB,WAAW,GAAE,MAAsB,GAClC,OAAO,CAAC;IACT,cAAc,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAC5B,aAAa,EAAE,GAAG,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC;CAC5C,CAAC,CAoCD;AAED;;;;;;;GAOG;AACH,wBAAsB,qBAAqB,CACzC,WAAW,EAAE,MAAM,EACnB,OAAO,CAAC,EAAE;IACR,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,uBAAuB,CAAC,EAAE,MAAM,EAAE,CAAC;CACpC,GACA,OAAO,CAAC;IACT,QAAQ,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IACtB,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC;CACtC,CAAC,CAoDD;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,UAAU,CAAC,MAAM,EAAE;IACjC,cAAc,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAC5B,aAAa,EAAE,GAAG,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC;IAC3C,QAAQ,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IACtB,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC;IACrC,uEAAuE;IACvE,0BAA0B,CAAC,EAAE,MAAM,EAAE,CAAC;CACvC,GAAG,QAAQ,CA0DX;AAMD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,8BAA8B,CAC5C,aAAa,EAAE,MAAM,EACrB,WAAW,GAAE,MAAsB,GAClC,MAAM,EAAE,CA0CV"}
+{"version":3,"file":"schema-sync.d.ts","sourceRoot":"","sources":["../../../../src/commands/db/utils/schema-sync.ts"],"names":[],"mappings":"AA0KA,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB;AAED,MAAM,WAAW,QAAQ;IACvB,cAAc,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAC5B,aAAa,EAAE,GAAG,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC;IAC3C,QAAQ,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IACtB,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC;IAErC,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,mBAAmB,EAAE,KAAK,CAAC;QACzB,IAAI,EAAE,MAAM,CAAC;QACb,QAAQ,EAAE,MAAM,EAAE,CAAC;QACnB,YAAY,EAAE,MAAM,EAAE,CAAC;QACvB,KAAK,EAAE,MAAM,EAAE,CAAC;QAChB,OAAO,EAAE,MAAM,EAAE,CAAC;KACnB,CAAC,CAAC;CACJ;AAMD;;;;;;;;;;;GAWG;AACH,wBAAsB,2BAA2B,CAC/C,aAAa,EAAE,MAAM,EACrB,WAAW,GAAE,MAAsB,GAClC,OAAO,CAAC;IACT,cAAc,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAC5B,aAAa,EAAE,GAAG,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC;CAC5C,CAAC,CA6CD;AAED;;;;;;;GAOG;AACH,wBAAsB,qBAAqB,CACzC,WAAW,EAAE,MAAM,EACnB,OAAO,CAAC,EAAE;IACR,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,uBAAuB,CAAC,EAAE,MAAM,EAAE,CAAC;CACpC,GACA,OAAO,CAAC;IACT,QAAQ,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IACtB,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC;CACtC,CAAC,CAoDD;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,UAAU,CAAC,MAAM,EAAE;IACjC,cAAc,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAC5B,aAAa,EAAE,GAAG,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC;IAC3C,QAAQ,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IACtB,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC;IACrC,uEAAuE;IACvE,0BAA0B,CAAC,EAAE,MAAM,EAAE,CAAC;CACvC,GAAG,QAAQ,CA0DX;AAMD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,8BAA8B,CAC5C,aAAa,EAAE,MAAM,EACrB,WAAW,GAAE,MAAsB,GAClC,MAAM,EAAE,CA0CV"}

package/dist/commands/dev/commands/dev.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dev.d.ts","sourceRoot":"","sources":["../../../../src/commands/dev/commands/dev.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAIH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAuMpC,eAAO,MAAM,UAAU,SAiBnB,CAAC"}
+{"version":3,"file":"dev.d.ts","sourceRoot":"","sources":["../../../../src/commands/dev/commands/dev.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAIH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAuMpC,eAAO,MAAM,UAAU,SAmBnB,CAAC"}

package/dist/commands/dev/contract.d.ts

@@ -18,6 +18,7 @@ export declare const DevInputSchema: z.ZodObject<{
     skipDb: z.ZodDefault<z.ZodBoolean>;
     skipApp: z.ZodDefault<z.ZodBoolean>;
     verbose: z.ZodDefault<z.ZodBoolean>;
+    stream: z.ZodDefault<z.ZodBoolean>;
     targetDir: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>;
 export type DevInput = z.infer<typeof DevInputSchema>;

package/dist/commands/dev/contract.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"contract.d.ts","sourceRoot":"","sources":["../../../src/commands/dev/contract.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB;;GAEG;AACH,eAAO,MAAM,cAAc;;;;;;kBAahB,CAAC;AAEZ,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAMtD;;GAEG;AACH,eAAO,MAAM,oBAAoB;;;;;;EAAgE,CAAC;AAElG,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAMlE;;GAEG;AACH,eAAO,MAAM,eAAe;;;;;;kBAajB,CAAC;AAEZ,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC"}
+{"version":3,"file":"contract.d.ts","sourceRoot":"","sources":["../../../src/commands/dev/contract.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB;;GAEG;AACH,eAAO,MAAM,cAAc;;;;;;;kBAehB,CAAC;AAEZ,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAMtD;;GAEG;AACH,eAAO,MAAM,oBAAoB;;;;;;EAAgE,CAAC;AAElG,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAMlE;;GAEG;AACH,eAAO,MAAM,eAAe;;;;;;kBAajB,CAAC;AAEZ,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC"}

package/dist/commands/dev/machine.d.ts

@@ -30,6 +30,7 @@ interface AppStartInput {
     appDir: string;
     port: number;
     tmpDir: string;
+    stream: boolean;
 }
 interface AppStartOutput {
     pid: number;

package/dist/commands/dev/machine.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"machine.d.ts","sourceRoot":"","sources":["../../../src/commands/dev/machine.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAIH,OAAO,EAAiB,KAAK,YAAY,EAAE,MAAM,QAAQ,CAAC;AAS1D,OAAO,KAAK,EAAE,UAAU,EAAY,QAAQ,EAAa,MAAM,YAAY,CAAC;AAsF5E,UAAU,aAAa;IACrB,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,UAAU,cAAc;IACtB,GAAG,EAAE,MAAM,CAAC;IACZ,cAAc,EAAE,MAAM,IAAI,CAAC;CAC5B;AAkCD,UAAU,aAAa;IACrB,GAAG,EAAE,MAAM,CAAC;CACb;AAoBD,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAIH,QAAQ;cAAY,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;EA6K5C,CAAC;AAMH,MAAM,MAAM,UAAU,GAAG,OAAO,UAAU,CAAC;AAC3C,MAAM,MAAM,WAAW,GAAG,YAAY,CAAC,OAAO,UAAU,CAAC,CAAC;AAM1D;;GAEG;AACH,wBAAgB,YAAY,CAAC,QAAQ,EAAE,WAAW,GAAG,MAAM,CAa1D;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,QAAQ,EAAE,WAAW,GAAG,OAAO,CAEzD;AAED;;GAEG;AACH,wBAAgB,QAAQ,CAAC,QAAQ,EAAE,WAAW,GAAG,MAAM,GAAG,IAAI,CAE7D"}
+{"version":3,"file":"machine.d.ts","sourceRoot":"","sources":["../../../src/commands/dev/machine.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAIH,OAAO,EAAiB,KAAK,YAAY,EAAE,MAAM,QAAQ,CAAC;AAS1D,OAAO,KAAK,EAAE,UAAU,EAAY,QAAQ,EAAa,MAAM,YAAY,CAAC;AAsF5E,UAAU,aAAa;IACrB,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,OAAO,CAAC;CACjB;AAED,UAAU,cAAc;IACtB,GAAG,EAAE,MAAM,CAAC;IACZ,cAAc,EAAE,MAAM,IAAI,CAAC;CAC5B;AAoCD,UAAU,aAAa;IACrB,GAAG,EAAE,MAAM,CAAC;CACb;AAoBD,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAIH,QAAQ;cAAY,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;EA8K5C,CAAC;AAMH,MAAM,MAAM,UAAU,GAAG,OAAO,UAAU,CAAC;AAC3C,MAAM,MAAM,WAAW,GAAG,YAAY,CAAC,OAAO,UAAU,CAAC,CAAC;AAM1D;;GAEG;AACH,wBAAgB,YAAY,CAAC,QAAQ,EAAE,WAAW,GAAG,MAAM,CAa1D;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,QAAQ,EAAE,WAAW,GAAG,OAAO,CAEzD;AAED;;GAEG;AACH,wBAAgB,QAAQ,CAAC,QAAQ,EAAE,WAAW,GAAG,MAAM,GAAG,IAAI,CAE7D"}

package/dist/commands/env/commands/env-pull.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"env-pull.d.ts","sourceRoot":"","sources":["../../../../src/commands/env/commands/env-pull.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AAaH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AA88BpC,eAAO,MAAM,WAAW,SA+BpB,CAAC"}
+{"version":3,"file":"env-pull.d.ts","sourceRoot":"","sources":["../../../../src/commands/env/commands/env-pull.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AAaH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAu9BpC,eAAO,MAAM,WAAW,SA+BpB,CAAC"}

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

@@ -1,18 +1,33 @@
 /**
  * AI HINT: Local Supabase Constants
  *
- * Purpose: Fixed values for local Supabase development (supabase start)
+ * Purpose: Dynamic values for local Supabase development (supabase start)
  * These are public, well-known values used by all Supabase CLI installations.
  *
  * Source: https://supabase.com/docs/guides/cli/local-development
  *
+ * Port Detection (Priority Order):
+ * 1. supabase/config.toml [api].port and [db].port settings
+ * 2. Default Supabase ports (54321 for API, 54322 for DB)
+ *
  * Note: These keys are intentionally public and NOT secrets.
  * They are the same for all local Supabase instances.
  */
+interface SupabasePorts {
+    api: number;
+    db: number;
+}
 /**
- * Local Supabase URL (default port: 54321)
+ * Detect Supabase ports from config.toml or use defaults.
+ *
+ * Priority:
+ * 1. supabase/config.toml settings
+ * 2. Default ports (54321/54322)
+ *
+ * @param projectRoot - Project root directory (defaults to process.cwd())
+ * @returns Detected ports
  */
-export declare const LOCAL_SUPABASE_URL = "http://127.0.0.1:54321";
+export declare function detectLocalSupabasePorts(projectRoot?: string): SupabasePorts;
 /**
  * Local Supabase anon key (fixed, public value)
  * This is the same for all local Supabase instances.
@@ -24,20 +39,57 @@ export declare const LOCAL_SUPABASE_ANON_KEY = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpX
  */
 export declare const LOCAL_SUPABASE_SERVICE_ROLE_KEY = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZS1kZW1vIiwicm9sZSI6InNlcnZpY2Vfcm9sZSIsImV4cCI6MTk4MzgxMjk5Nn0.EGIM96RAZx35lJzdJsyH-qQwv8Hdp7fsn3W0YpN81IU";
 /**
- * Local PostgreSQL URL (default port: 54322)
- * User: postgres, Password: postgres (default local credentials)
+ * Build local Supabase URL from detected port.
  */
-export declare const LOCAL_DATABASE_URL = "postgresql://postgres:postgres@127.0.0.1:54322/postgres";
+export declare function buildLocalSupabaseUrl(projectRoot?: string): string;
+/**
+ * Build local database URL from detected port.
+ */
+export declare function buildLocalDatabaseUrl(projectRoot?: string): string;
+/**
+ * Get map of environment variable keys to their local Supabase values.
+ *
+ * This function dynamically generates values based on detected ports.
+ *
+ * @param projectRoot - Project root directory (defaults to process.cwd())
+ * @returns Environment variable key-value map
+ */
+export declare function getLocalSupabaseEnvValues(projectRoot?: string): Record<string, string>;
 /**
- * Map of environment variable keys to their local Supabase values
+ * Get human-readable descriptions for each local value (for summary display).
+ *
+ * @param projectRoot - Project root directory (defaults to process.cwd())
+ * @returns Description map
+ */
+export declare function getLocalValueDescriptions(projectRoot?: string): Record<string, string>;
+/**
+ * @deprecated Use getLocalSupabaseEnvValues() instead.
+ * This constant uses default ports; prefer the function for dynamic port detection.
  */
 export declare const LOCAL_SUPABASE_ENV_VALUES: Record<string, string>;
 /**
- * List of keys to replace with local values in .env.development
+ * @deprecated Use Object.keys(getLocalSupabaseEnvValues()) instead.
  */
 export declare const LOCAL_REPLACEMENT_KEYS: string[];
 /**
- * Human-readable descriptions for each local value (for summary display)
+ * @deprecated Use getLocalValueDescriptions() instead.
  */
 export declare const LOCAL_VALUE_DESCRIPTIONS: Record<string, string>;
+/**
+ * @deprecated Use buildLocalSupabaseUrl() instead.
+ */
+export declare const LOCAL_SUPABASE_URL = "http://127.0.0.1:54321";
+/**
+ * @deprecated Use buildLocalDatabaseUrl() instead.
+ */
+export declare const LOCAL_DATABASE_URL = "postgresql://postgres:postgres@127.0.0.1:54322/postgres";
+/**
+ * Validate that all URL values point to localhost.
+ * This prevents accidental production URL usage in local development.
+ *
+ * @param envValues - Environment values to validate
+ * @throws Error if any URL doesn't point to localhost
+ */
+export declare function validateLocalhostValues(envValues: Record<string, string>): void;
+export {};
 //# sourceMappingURL=local-supabase.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"local-supabase.d.ts","sourceRoot":"","sources":["../../../../src/commands/env/constants/local-supabase.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH;;GAEG;AACH,eAAO,MAAM,kBAAkB,2BAA2B,CAAC;AAE3D;;;GAGG;AACH,eAAO,MAAM,uBAAuB,8JACyH,CAAC;AAE9J;;;GAGG;AACH,eAAO,MAAM,+BAA+B,yKAC4H,CAAC;AAEzK;;;GAGG;AACH,eAAO,MAAM,kBAAkB,4DAA4D,CAAC;AAE5F;;GAEG;AACH,eAAO,MAAM,yBAAyB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAU5D,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,sBAAsB,UAAyC,CAAC;AAE7E;;GAEG;AACH,eAAO,MAAM,wBAAwB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAO3D,CAAC"}
+{"version":3,"file":"local-supabase.d.ts","sourceRoot":"","sources":["../../../../src/commands/env/constants/local-supabase.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAgBH,UAAU,aAAa;IACrB,GAAG,EAAE,MAAM,CAAC;IACZ,EAAE,EAAE,MAAM,CAAC;CACZ;AA6DD;;;;;;;;;GASG;AACH,wBAAgB,wBAAwB,CAAC,WAAW,GAAE,MAAsB,GAAG,aAAa,CAW3F;AAMD;;;GAGG;AACH,eAAO,MAAM,uBAAuB,8JACyH,CAAC;AAE9J;;;GAGG;AACH,eAAO,MAAM,+BAA+B,yKAC4H,CAAC;AAEzK;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,WAAW,GAAE,MAAsB,GAAG,MAAM,CAGjF;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,WAAW,GAAE,MAAsB,GAAG,MAAM,CAGjF;AAED;;;;;;;GAOG;AACH,wBAAgB,yBAAyB,CACvC,WAAW,GAAE,MAAsB,GAClC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAexB;AAED;;;;;GAKG;AACH,wBAAgB,yBAAyB,CACvC,WAAW,GAAE,MAAsB,GAClC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAWxB;AAMD;;;GAGG;AACH,eAAO,MAAM,yBAAyB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAA+B,CAAC;AAE7F;;GAEG;AACH,eAAO,MAAM,sBAAsB,UAAyC,CAAC;AAE7E;;GAEG;AACH,eAAO,MAAM,wBAAwB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAA+B,CAAC;AAE5F;;GAEG;AACH,eAAO,MAAM,kBAAkB,2BAAyC,CAAC;AAEzE;;GAEG;AACH,eAAO,MAAM,kBAAkB,4DAAyE,CAAC;AAMzG;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CAAC,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI,CAwB/E"}

package/dist/commands/template-check/config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../../src/commands/template-check/config.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAMH;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,eAAe,2CAA4C,CAAC;AAMzE;;;;GAIG;AACH,eAAO,MAAM,eAAe,EAAE,SAAS,MAAM,EA4DnC,CAAC;AAEX;;;;GAIG;AACH,eAAO,MAAM,mBAAmB,EAAE,SAAS,MAAM,EAwDvC,CAAC;AAMX;;;;;;GAMG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8EvB,CAAC;AAMX;;;;;;GAMG;AACH,eAAO,MAAM,6BAA6B,EAAE,SAAS,MAAM,EA6DjD,CAAC"}
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../../src/commands/template-check/config.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAMH;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,eAAe,2CAA4C,CAAC;AAMzE;;;;GAIG;AACH,eAAO,MAAM,eAAe,EAAE,SAAS,MAAM,EAuEnC,CAAC;AAEX;;;;GAIG;AACH,eAAO,MAAM,mBAAmB,EAAE,SAAS,MAAM,EAwDvC,CAAC;AAMX;;;;;;GAMG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8EvB,CAAC;AAMX;;;;;;GAMG;AACH,eAAO,MAAM,6BAA6B,EAAE,SAAS,MAAM,EA6DjD,CAAC"}

package/dist/index.js

@@ -868,7 +868,7 @@ __export(types_exports, {
   calculateSummary: () => calculateSummary,
   createInitialContext: () => createInitialContext2,
   createOutput: () => createOutput4,
-  getErrorMessage: () => getErrorMessage2
+  getErrorMessage: () => getErrorMessage
 });
 function createInitialContext2(input3, repoRoot) {
   return {
@@ -915,7 +915,7 @@ function createOutput4(context) {
     durationMs
   };
 }
-function getErrorMessage2(error) {
+function getErrorMessage(error) {
   return error instanceof Error ? error.message : String(error);
 }
 var init_types = __esm({
@@ -929,7 +929,7 @@ var CLI_VERSION, HAS_ADMIN_COMMAND;
 var init_version = __esm({
   "src/version.ts"() {
     init_esm_shims();
-    CLI_VERSION = "0.5.44";
+    CLI_VERSION = "0.5.46";
     HAS_ADMIN_COMMAND = false;
   }
 });
@@ -7432,6 +7432,8 @@ z.object({
   skipApp: z.boolean().default(false),
   /** Show detailed output */
   verbose: z.boolean().default(false),
+  /** Stream app output to terminal (in addition to log file). Default: true */
+  stream: z.boolean().default(true),
   /** Target directory (defaults to cwd) */
   targetDir: z.string().optional()
 }).strict();
@@ -7653,9 +7655,9 @@ async function executePrSetupBase(input3, ensureTmpDir) {
 // src/commands/ci/utils/app-runtime.ts
 init_esm_shims();
 function pipeChildOutputToLog(params) {
-  const sources = [params.stdout, params.stderr].filter(
-    (s) => s != null
-  );
+  const sources = [];
+  if (params.stdout) sources.push({ stream: params.stdout, isStderr: false });
+  if (params.stderr) sources.push({ stream: params.stderr, isStderr: true });
   if (sources.length === 0) {
     params.logStream.end();
     return { cleanup: () => {
@@ -7669,10 +7671,14 @@ function pipeChildOutputToLog(params) {
       params.logStream.end();
     }
   };
-  for (const source of sources) {
+  for (const { stream: source, isStderr } of sources) {
     const onData = (chunk) => {
       if (cleanedUp) return;
       const canContinue = params.logStream.write(chunk);
+      if (params.streamToTerminal) {
+        const terminalStream = isStderr ? process.stderr : process.stdout;
+        terminalStream.write(chunk);
+      }
       if (!canContinue) {
         source.pause();
         params.logStream.once("drain", () => {
@@ -7690,7 +7696,7 @@ function pipeChildOutputToLog(params) {
   const cleanup = () => {
     if (cleanedUp) return;
     cleanedUp = true;
-    for (const source of sources) {
+    for (const { stream: source } of sources) {
       source.removeAllListeners("data");
       source.removeAllListeners("end");
       source.removeAllListeners("close");
@@ -7787,33 +7793,37 @@ async function readPackageScripts(pkgPath) {
     return null;
   }
 }
-function determineStartCommand(isMonorepo2, rootScripts, appScripts, repoRoot, appDir, port) {
-  const rootHasStartCi = Boolean(rootScripts?.["start:ci"]);
-  const rootHasStart = Boolean(rootScripts?.start);
-  const appHasStartCi = Boolean(appScripts?.["start:ci"]);
-  const appHasStart = Boolean(appScripts?.start);
-  if (isMonorepo2 && (rootHasStartCi || rootHasStart)) {
-    const scriptName = rootHasStartCi ? "start:ci" : "start";
+function determineAppCommand(mode, isMonorepo2, rootScripts, appScripts, repoRoot, appDir, port) {
+  const ciScriptName = mode === "dev" ? "dev:ci" : "start:ci";
+  const nextCommand = mode === "dev" ? "dev" : "start";
+  const rootHasCiScript = Boolean(rootScripts?.[ciScriptName]);
+  const appHasCiScript = Boolean(appScripts?.[ciScriptName]);
+  const rootHasDefaultScript = mode === "start" && Boolean(rootScripts?.["start"]);
+  const appHasDefaultScript = mode === "start" && Boolean(appScripts?.["start"]);
+  if (isMonorepo2 && (rootHasCiScript || rootHasDefaultScript)) {
+    const scriptName = rootHasCiScript ? ciScriptName : "start";
     return { command: ["pnpm", scriptName], useRootScript: true };
   }
-  if (appHasStartCi || appHasStart) {
-    const scriptName = appHasStartCi ? "start:ci" : "start";
+  if (appHasCiScript || appHasDefaultScript) {
+    const scriptName = appHasCiScript ? ciScriptName : "start";
     const dirArgs2 = isMonorepo2 ? ["-C", path10__default.relative(repoRoot, appDir)] : [];
     return { command: ["pnpm", ...dirArgs2, scriptName], useRootScript: false };
   }
   const dirArgs = isMonorepo2 ? ["-C", path10__default.relative(repoRoot, appDir)] : [];
   return {
-    command: ["pnpm", ...dirArgs, "exec", "next", "start", "-p", String(port)],
+    command: ["pnpm", ...dirArgs, "exec", "next", nextCommand, "-p", String(port)],
     useRootScript: false
   };
 }
 async function startAppBackground(params) {
+  const mode = params.mode ?? "start";
   const isMonorepo2 = params.appDir !== params.repoRoot;
   const rootPkgPath = path10__default.join(params.repoRoot, "package.json");
   const appPkgPath = path10__default.join(params.appDir, "package.json");
   const rootScripts = await readPackageScripts(rootPkgPath);
   const appScripts = isMonorepo2 ? await readPackageScripts(appPkgPath) : rootScripts;
-  const { command, useRootScript } = determineStartCommand(
+  const { command, useRootScript } = determineAppCommand(
+    mode,
     isMonorepo2,
     rootScripts,
     appScripts,
@@ -7824,8 +7834,10 @@ async function startAppBackground(params) {
   const appLog = path10__default.join(params.tmpDir, "app.log");
   const out = createWriteStream(appLog, { flags: "a" });
   const commandStr = command.join(" ");
+  const modeLabel = mode === "dev" ? "development (hot reload)" : "production";
   const logHeader = [
     `[runa] Starting app at ${(/* @__PURE__ */ new Date()).toISOString()}`,
+    `[runa] Mode: ${modeLabel}`,
     `[runa] Command: ${commandStr}`,
     `[runa] Working directory: ${params.repoRoot}`,
     `[runa] App directory: ${path10__default.relative(params.repoRoot, params.appDir) || "."}`,
@@ -7845,7 +7857,8 @@ async function startAppBackground(params) {
   const { cleanup: cleanupStreams } = pipeChildOutputToLog({
     stdout: child.stdout,
     stderr: child.stderr,
-    logStream: out
+    logStream: out,
+    streamToTerminal: params.stream
   });
   const pid = child.pid ?? -1;
   await writeFile(path10__default.join(params.tmpDir, "app.pid"), `${pid}
@@ -7992,7 +8005,7 @@ var e2eMeta2 = {
 };
 var appStartActor = fromPromise(
   async ({ input: input3 }) => {
-    const { repoRoot, appDir, port, tmpDir } = input3;
+    const { repoRoot, appDir, port, tmpDir, stream } = input3;
     const fullTmpDir = path10__default.join(repoRoot, tmpDir);
     await mkdir(fullTmpDir, { recursive: true });
     const result = await startAppBackground({
@@ -8000,7 +8013,9 @@ var appStartActor = fromPromise(
       appDir,
       port,
       env: process.env,
-      tmpDir: fullTmpDir
+      tmpDir: fullTmpDir,
+      mode: "dev",
+      stream
     });
     await waitForAppReady({
       port,
@@ -8039,7 +8054,7 @@ var devMachine = setup({
   id: "dev",
   initial: "idle",
   context: ({ input: input3 }) => {
-    const repoRoot = input3.repoRoot;
+    const repoRoot = input3.repoRoot ?? process.cwd();
     return {
       input: input3.input,
       repoRoot,
@@ -8133,7 +8148,8 @@ var devMachine = setup({
             repoRoot: context.repoRoot,
             appDir: detected?.appDir ?? context.repoRoot,
             port: context.input.port,
-            tmpDir: context.tmpDir
+            tmpDir: context.tmpDir,
+            stream: context.input.stream
           };
         },
         onDone: {
@@ -8336,12 +8352,13 @@ async function runDevAction(options, cmd) {
     );
   }
 }
-var devCommand = new Command("dev").description("Start development server (Supabase + Next.js)").option("--port <number>", "Port for Next.js dev server", (val) => Number.parseInt(val, 10), 3e3).option("--skip-db", "Skip Supabase start").option("--skip-app", "Start Supabase only (no app server)").option("--verbose", "Show detailed output").option("--target-dir <path>", "Target directory (defaults to repo root)").action(async (options, cmd) => {
+var devCommand = new Command("dev").description("Start development server (Supabase + Next.js)").option("--port <number>", "Port for Next.js dev server", (val) => Number.parseInt(val, 10), 3e3).option("--skip-db", "Skip Supabase start").option("--skip-app", "Start Supabase only (no app server)").option("--verbose", "Show detailed output").option("--no-stream", "Disable streaming app output to terminal (log to file only)").option("--target-dir <path>", "Target directory (defaults to repo root)").action(async (options, cmd) => {
   const input3 = {
     port: options.port,
     skipDb: options.skipDb ?? false,
     skipApp: options.skipApp ?? false,
     verbose: options.verbose ?? false,
+    stream: options.stream ?? true,
     targetDir: options.targetDir
   };
   await runDevAction(input3, cmd);
@@ -14806,9 +14823,6 @@ function createOutput3(context) {
     error: context.error ?? void 0
   };
 }
-function getErrorMessage(error) {
-  return error instanceof Error ? error.message : String(error);
-}
 function extractErrorMessage2(event, fallbackMessage) {
   return event.error instanceof Error ? event.error.message : fallbackMessage;
 }
@@ -15034,7 +15048,6 @@ var ciMachine = setup({
       invoke: {
         src: "upsertComment",
         input: ({ context }) => {
-          console.log("[DEBUG] initialComment: Posting initial progress comment");
           const prNumber = context.prContext?.prNumber ?? 0;
           const progressInput = createProgressCommentInput(
             context,
@@ -15592,11 +15605,7 @@ ${generateProgressCommentBody(progressInput)}`;
             // Core tests failed - go to coreTestsFailed
             guard: ({ event }) => {
               const failedLayers = event.output.failedLayers ?? [];
-              const hasFailures = failedLayers.length > 0;
-              console.log(
-                `[DEBUG] runCoreTests.onDone guard: failedLayers=${JSON.stringify(failedLayers)}, hasFailures=${hasFailures}`
-              );
-              return hasFailures;
+              return failedLayers.length > 0;
             },
             target: "coreTestsFailed",
             actions: assign({
@@ -15605,9 +15614,6 @@ ${generateProgressCommentBody(progressInput)}`;
                 const results = event.output.results ?? [];
                 const failedLayers = event.output.failedLayers ?? [];
                 if (results.length === 0 && failedLayers.length > 0) {
-                  console.log(
-                    `[DEBUG] Converting failedLayers to layerResults: ${JSON.stringify(failedLayers)}`
-                  );
                   const layerResults = {};
                   for (const layer of failedLayers) {
                     layerResults[layer] = { status: "failed", exitCode: 1 };
@@ -15662,7 +15668,6 @@ ${generateProgressCommentBody(progressInput)}`;
       entry: assign({
         exitCode: ({ context }) => {
           if (Object.keys(context.layerResults).length === 0) {
-            console.log("[DEBUG] coreTestsFailed: layerResults is empty, returning exitCode=1");
             return 1;
           }
           return computeExitCodeFromLayerResults(context.layerResults);
@@ -15687,7 +15692,6 @@ ${generateProgressCommentBody(progressInput)}`;
           assertions: [{ type: "log", contains: "E2E phase" }]
         }
       },
-      entry: () => console.log("[DEBUG] Entering e2ePhase (parallel: comment + E2E tests)"),
       states: {
         // Sub-state 1: Post intermediate comment
         intermediateComment: {
@@ -15712,7 +15716,6 @@ ${generateProgressCommentBody(progressInput)}`;
               invoke: {
                 src: "upsertComment",
                 input: ({ context }) => {
-                  console.log("[DEBUG] e2ePhase.intermediateComment: Posting intermediate comment");
                   const prNumber = context.prContext?.prNumber ?? 0;
                   const commentInput = createCommentInput(context, {
                     isIntermediate: true,
@@ -15742,7 +15745,6 @@ ${generateCommentBody(commentInput)}`;
               invoke: {
                 src: "runLayers",
                 input: ({ context }) => {
-                  console.log("[DEBUG] e2ePhase.e2eTests: Running Layer 4");
                   const e2eBaseUrl = `http://localhost:${context.app?.port ?? 3e3}`;
                   return {
                     repoRoot: assertRepoRoot(context),
@@ -15768,9 +15770,6 @@ ${generateCommentBody(commentInput)}`;
                     // Merge E2E results into layerResults
                     layerResults: ({ context, event }) => {
                       const e2eResults = convertLayerResults(event.output.results);
-                      console.log(
-                        `[DEBUG] e2ePhase.e2eTests: E2E results=${JSON.stringify(e2eResults)}`
-                      );
                       return mergeLayerResults(context.layerResults, e2eResults);
                     }
                   })
@@ -15795,7 +15794,6 @@ ${generateCommentBody(commentInput)}`;
       onDone: {
         target: "finalize",
         actions: [
-          () => console.log("[DEBUG] e2ePhase complete, transitioning to finalize"),
           // Compute final exit code including E2E results
           assign({
             exitCode: ({ context }) => computeExitCodeFromLayerResults(context.layerResults)
@@ -15859,113 +15857,47 @@ ${generateCommentBody(commentInput)}`;
           }
         },
         postComment: {
-          entry: () => {
-            console.log("[DEBUG] Entering postComment state");
-          },
           always: [
             {
               // Skip if GitHub comment should not be posted (mode, env, flag checks)
-              guard: ({ context }) => {
-                const shouldPost = shouldPostGitHubComment(context);
-                const isCiPr = isCiPrMode(context);
-                console.log(
-                  `[DEBUG] postComment guard: shouldPost=${shouldPost}, isCiPr=${isCiPr}, mode=${context.mode}, env=${context.executionEnv}, skipFlag=${context.input.skipGithubComment}`
-                );
-                if (!shouldPost) {
-                  console.log(
-                    `[DEBUG] Skipping final comment: shouldPostGitHubComment=false (mode=${context.mode}, env=${context.executionEnv})`
-                  );
-                }
-                return !shouldPost;
-              },
+              guard: ({ context }) => !shouldPostGitHubComment(context),
               target: "complete"
             },
             {
               // Skip if PR number is not available (can't post without it)
-              guard: ({ context }) => {
-                const skip = !context.prContext?.prNumber;
-                if (skip) {
-                  console.log("[DEBUG] Skipping final comment: prNumber not available");
-                }
-                return skip;
-              },
+              guard: ({ context }) => !context.prContext?.prNumber,
               target: "complete"
             }
           ],
           invoke: {
             src: "upsertComment",
             input: ({ context }) => {
-              try {
-                const prNumber = assertPrNumber(context);
-                console.log(`[DEBUG] Posting final comment to PR #${prNumber}`);
-                const commentInput = createCommentInput(context);
-                const body = `<!-- runa-ci-report -->
+              const prNumber = assertPrNumber(context);
+              const commentInput = createCommentInput(context);
+              const body = `<!-- runa-ci-report -->
 ${generateCommentBody(commentInput)}`;
-                return {
-                  // repo is optional, resolved from environment inside actor
-                  issueNumber: prNumber,
-                  marker: "<!-- runa-ci-report -->",
-                  body
-                };
-              } catch (error) {
-                console.error(
-                  `[DEBUG] Failed to generate comment body: ${error instanceof Error ? error.message : String(error)}`
-                );
-                throw error;
-              }
-            },
-            onDone: {
-              target: "complete",
-              actions: ({ event }) => {
-                if (event.output.success) {
-                  console.log("[DEBUG] Final comment posted successfully");
-                } else {
-                  console.error(
-                    `[DEBUG] Failed to post final comment: ${event.output.error ?? "Unknown error"}`
-                  );
-                }
-              }
+              return {
+                issueNumber: prNumber,
+                marker: "<!-- runa-ci-report -->",
+                body
+              };
             },
-            onError: {
-              target: "complete",
-              actions: ({ event }) => {
-                console.error(
-                  `[DEBUG] postComment actor error: ${event.error instanceof Error ? event.error.message : String(event.error)}`
-                );
-              }
-            }
+            onDone: { target: "complete" },
+            onError: { target: "complete" }
           }
         },
         complete: {
-          entry: () => {
-            console.log("[DEBUG] Entered finalize.complete (final sub-state)");
-          },
           type: "final"
         }
       },
       onDone: [
-        {
-          guard: ({ context }) => context.exitCode !== 0,
-          target: "failed",
-          actions: () => {
-            console.log("[DEBUG] finalize.onDone -> failed");
-          }
-        },
-        {
-          target: "done",
-          actions: () => {
-            console.log("[DEBUG] finalize.onDone -> done");
-          }
-        }
+        { guard: ({ context }) => context.exitCode !== 0, target: "failed" },
+        { target: "done" }
       ],
       exit: [
-        // Stop the app if it was started
         ({ context }) => {
           if (context.appPid) {
-            stopApp(context.appPid).catch((error) => {
-              console.error(
-                `[DEBUG] Warning: Failed to stop app (pid: ${context.appPid}): ${getErrorMessage(error)}`
-              );
+            stopApp(context.appPid).catch(() => {
             });
           }
         }
@@ -15985,23 +15917,13 @@ ${generateCommentBody(commentInput)}`;
         }
       },
       type: "final",
-      entry: [
-        () => console.log("[DEBUG] Entered final state: done"),
-        // Safety: Ensure exitCode reflects actual layer results even if testsFailed was bypassed
-        assign({
-          durationMs: () => Date.now(),
-          exitCode: ({ context }) => {
-            if (context.exitCode !== 0) return context.exitCode;
-            const computed = computeExitCodeFromLayerResults(context.layerResults);
-            if (computed !== 0) {
-              console.log(
-                `[DEBUG] done state: Computing exitCode from layerResults: ${computed} (was ${context.exitCode})`
-              );
-            }
-            return computed;
-          }
-        })
-      ]
+      entry: assign({
+        durationMs: () => Date.now(),
+        exitCode: ({ context }) => {
+          if (context.exitCode !== 0) return context.exitCode;
+          return computeExitCodeFromLayerResults(context.layerResults);
+        }
+      })
     },
     failed: {
       meta: {
@@ -16015,14 +15937,10 @@ ${generateCommentBody(commentInput)}`;
       },
       type: "final",
       entry: [
-        ({ context }) => console.log(`[DEBUG] Entered final state: failed (exitCode=${context.exitCode})`),
-        // Preserve exit code from testsFailed if already set, otherwise compute
-        // If there's an error (actor failure), always return 1
         assign({
           exitCode: ({ context }) => context.exitCode !== 0 ? context.exitCode : context.error ? 1 : computeExitCodeFromLayerResults(context.layerResults),
           durationMs: () => Date.now()
         }),
-        // Stop the app if it was started
         ({ context }) => {
           if (context.appPid) {
             stopApp(context.appPid).catch(() => {
@@ -19914,7 +19832,14 @@ function uniqueSorted(values) {
 async function extractSchemaTablesAndEnums(dbPackagePath, projectRoot = process.cwd()) {
   const validatedSchemaPath = validateSchemaPath(dbPackagePath, projectRoot);
   const jiti = createJiti(projectRoot, { interopDefault: true });
-  const schemaModule = await jiti.import(validatedSchemaPath);
+  let schemaModule;
+  try {
+    schemaModule = await jiti.import(validatedSchemaPath);
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    const hint = errorMessage.includes("unknown is not defined") ? "\n\nHint: Add 'unknown' to drizzle-orm/pg-core imports:\n  import { unknown, ... } from 'drizzle-orm/pg-core'" : "";
+    throw new Error(`Failed to load schema from ${validatedSchemaPath}: ${errorMessage}${hint}`);
+  }
   const expectedTables = /* @__PURE__ */ new Set();
   const expectedEnums = /* @__PURE__ */ new Map();
   for (const value of Object.values(schemaModule)) {
@@ -24905,13 +24830,12 @@ var SKIP_DIRS = /* @__PURE__ */ new Set([
   "__snapshots__"
 ]);
 var MAX_FILE_SIZE = 1024 * 1024;
-var SCHEMA_IMPORT_PATTERNS = [
-  /from\s+['"]@runa-ai\/runa-database\/schema['"]/,
-  /from\s+['"]@runa\/database\/schema['"]/,
-  /from\s+['"]@runa\/database['"]/,
-  /from\s+['"].*\/database\/src\/schema['"]/,
-  /from\s+['"].*\/packages\/database\/src\/schema['"]/
+var SCHEMA_IMPORT_SOURCES = [
+  "@runa-ai/runa-database/schema",
+  "@runa/database/schema",
+  "@runa/database"
 ];
+var SCHEMA_RELATIVE_PATTERNS = [/\/database\/src\/schema/, /\/packages\/database\/src\/schema/];
 function findTsFiles(dir, files = []) {
   if (!existsSync(dir)) return files;
   const entries = readdirSync(dir, { withFileTypes: true });
@@ -24929,75 +24853,80 @@ function findTsFiles(dir, files = []) {
   }
   return files;
 }
-function extractSchemaImports(filePath, rootDir) {
+function isSchemaImport(moduleSpecifier) {
+  if (SCHEMA_IMPORT_SOURCES.includes(moduleSpecifier)) {
+    return true;
+  }
+  return SCHEMA_RELATIVE_PATTERNS.some((pattern) => pattern.test(moduleSpecifier));
+}
+function extractSchemaImportsFromAST(sourceFile, rootDir) {
   const imports = [];
+  const filePath = sourceFile.getFilePath();
+  const relativeFilePath = relative(rootDir, filePath);
+  const importDeclarations = sourceFile.getImportDeclarations();
+  for (const importDecl of importDeclarations) {
+    const moduleSpecifier = importDecl.getModuleSpecifierValue();
+    if (!isSchemaImport(moduleSpecifier)) {
+      continue;
+    }
+    const line = importDecl.getStartLineNumber();
+    const namedImports = importDecl.getNamedImports();
+    for (const namedImport of namedImports) {
+      const name = namedImport.getName();
+      const isTypeOnly = namedImport.isTypeOnly() || importDecl.isTypeOnly();
+      imports.push({
+        file: relativeFilePath,
+        line,
+        symbol: isTypeOnly ? `type ${name}` : name,
+        source: moduleSpecifier
+      });
+    }
+    const namespaceImport = importDecl.getNamespaceImport();
+    if (namespaceImport) {
+      imports.push({
+        file: relativeFilePath,
+        line,
+        symbol: `* as ${namespaceImport.getText()}`,
+        source: moduleSpecifier
+      });
+    }
+    const defaultImport = importDecl.getDefaultImport();
+    if (defaultImport) {
+      imports.push({
+        file: relativeFilePath,
+        line,
+        symbol: `default (${defaultImport.getText()})`,
+        source: moduleSpecifier
+      });
+    }
+  }
+  return imports;
+}
+function extractSchemaImports(filePath, rootDir, project) {
   try {
     const stats = statSync(filePath);
     if (stats.size > MAX_FILE_SIZE) {
-      return imports;
-    }
-    const content = readFileSync(filePath, "utf-8");
-    const lines = content.split("\n");
-    for (let i = 0; i < lines.length; i++) {
-      const line = lines[i];
-      const isSchemaImport = SCHEMA_IMPORT_PATTERNS.some((pattern) => pattern.test(line));
-      if (!isSchemaImport) continue;
-      const sourceMatch = line.match(/from\s+['"]([^'"]+)['"]/);
-      if (!sourceMatch) continue;
-      const source = sourceMatch[1];
-      const namedMatch = line.match(/import\s*\{([^}]+)\}/);
-      if (namedMatch) {
-        const symbols = namedMatch[1].split(",").map((s) => {
-          const parts = s.trim().split(/\s+as\s+/);
-          return parts[0].trim();
-        });
-        for (const symbol of symbols) {
-          if (symbol) {
-            imports.push({
-              file: relative(rootDir, filePath),
-              line: i + 1,
-              symbol,
-              source
-            });
-          }
-        }
-      }
-      const namespaceMatch = line.match(/import\s+\*\s+as\s+(\w+)/);
-      if (namespaceMatch) {
-        imports.push({
-          file: relative(rootDir, filePath),
-          line: i + 1,
-          symbol: `* as ${namespaceMatch[1]}`,
-          source
-        });
-      }
-      const typeMatch = line.match(/import\s+type\s*\{([^}]+)\}/);
-      if (typeMatch) {
-        const symbols = typeMatch[1].split(",").map(
-          (s) => s.trim().split(/\s+as\s+/)[0].trim()
-        );
-        for (const symbol of symbols) {
-          if (symbol) {
-            imports.push({
-              file: relative(rootDir, filePath),
-              line: i + 1,
-              symbol: `type ${symbol}`,
-              source
-            });
-          }
-        }
-      }
+      return [];
     }
+    const sourceFile = project.addSourceFileAtPath(filePath);
+    const imports = extractSchemaImportsFromAST(sourceFile, rootDir);
+    project.removeSourceFile(sourceFile);
+    return imports;
   } catch {
+    return [];
   }
-  return imports;
 }
 function analyzeImportImpact(rootDir) {
   const symbolUsage = /* @__PURE__ */ new Map();
   const tsFiles = findTsFiles(rootDir);
   let filesWithImports = 0;
+  const project = new Project({
+    skipAddingFilesFromTsConfig: true,
+    skipFileDependencyResolution: true,
+    skipLoadingLibFiles: true
+  });
   for (const file of tsFiles) {
-    const imports = extractSchemaImports(file, rootDir);
+    const imports = extractSchemaImports(file, rootDir, project);
     if (imports.length > 0) {
       filesWithImports++;
     }
@@ -26209,30 +26138,84 @@ async function getVercelRootDirectory() {
 
 // src/commands/env/constants/local-supabase.ts
 init_esm_shims();
-var LOCAL_SUPABASE_URL = "http://127.0.0.1:54321";
+var DEFAULT_API_PORT = 54321;
+var DEFAULT_DB_PORT = 54322;
+function parsePortFromToml(content, section, key) {
+  const sectionRegex = new RegExp(`\\[${section}\\]([\\s\\S]*?)(?=\\n\\[|$)`, "g");
+  const sectionMatch = sectionRegex.exec(content);
+  if (!sectionMatch) return null;
+  const sectionContent = sectionMatch[1];
+  const keyRegex = new RegExp(`^\\s*${key}\\s*=\\s*(\\d+)`, "m");
+  const keyMatch = keyRegex.exec(sectionContent);
+  if (!keyMatch) return null;
+  const port = Number.parseInt(keyMatch[1], 10);
+  return Number.isFinite(port) && port > 0 && port < 65536 ? port : null;
+}
+function readPortsFromConfigToml(projectRoot) {
+  const configPath = path10__default.join(projectRoot, "supabase", "config.toml");
+  try {
+    const content = readFileSync(configPath, "utf-8");
+    const apiPort = parsePortFromToml(content, "api", "port");
+    const dbPort = parsePortFromToml(content, "db", "port");
+    if (apiPort !== null || dbPort !== null) {
+      return {
+        api: apiPort ?? DEFAULT_API_PORT,
+        db: dbPort ?? DEFAULT_DB_PORT
+      };
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function detectLocalSupabasePorts(projectRoot = process.cwd()) {
+  const configPorts = readPortsFromConfigToml(projectRoot);
+  if (configPorts) {
+    return configPorts;
+  }
+  return {
+    api: DEFAULT_API_PORT,
+    db: DEFAULT_DB_PORT
+  };
+}
 var LOCAL_SUPABASE_ANON_KEY = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZS1kZW1vIiwicm9sZSI6ImFub24iLCJleHAiOjE5ODM4MTI5OTZ9.CRXP1A7WOeoJeXxjNni43kdQwgnWNReilDMblYTn_I0";
 var LOCAL_SUPABASE_SERVICE_ROLE_KEY = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZS1kZW1vIiwicm9sZSI6InNlcnZpY2Vfcm9sZSIsImV4cCI6MTk4MzgxMjk5Nn0.EGIM96RAZx35lJzdJsyH-qQwv8Hdp7fsn3W0YpN81IU";
-var LOCAL_DATABASE_URL = "postgresql://postgres:postgres@127.0.0.1:54322/postgres";
-var LOCAL_SUPABASE_ENV_VALUES = {
-  // Database URLs
-  DATABASE_URL: LOCAL_DATABASE_URL,
-  DATABASE_URL_ADMIN: LOCAL_DATABASE_URL,
-  DATABASE_URL_SERVICE: LOCAL_DATABASE_URL,
-  // Supabase URLs and keys
-  NEXT_PUBLIC_SUPABASE_URL: LOCAL_SUPABASE_URL,
-  NEXT_PUBLIC_SUPABASE_ANON_KEY: LOCAL_SUPABASE_ANON_KEY,
-  SUPABASE_SERVICE_ROLE_KEY: LOCAL_SUPABASE_SERVICE_ROLE_KEY
-};
-var LOCAL_REPLACEMENT_KEYS = Object.keys(LOCAL_SUPABASE_ENV_VALUES);
-var LOCAL_VALUE_DESCRIPTIONS = {
-  DATABASE_URL: "localhost:54322 (PostgreSQL)",
-  DATABASE_URL_ADMIN: "localhost:54322 (PostgreSQL)",
-  DATABASE_URL_SERVICE: "localhost:54322 (PostgreSQL)",
-  NEXT_PUBLIC_SUPABASE_URL: "localhost:54321 (Supabase API)",
-  NEXT_PUBLIC_SUPABASE_ANON_KEY: "local anon key (supabase-demo)",
-  SUPABASE_SERVICE_ROLE_KEY: "local service key (supabase-demo)"
-};
-function validateLocalhostValues() {
+function buildLocalSupabaseUrl(projectRoot = process.cwd()) {
+  const ports = detectLocalSupabasePorts(projectRoot);
+  return `http://127.0.0.1:${ports.api}`;
+}
+function buildLocalDatabaseUrl(projectRoot = process.cwd()) {
+  const ports = detectLocalSupabasePorts(projectRoot);
+  return `postgresql://postgres:postgres@127.0.0.1:${ports.db}/postgres`;
+}
+function getLocalSupabaseEnvValues(projectRoot = process.cwd()) {
+  const supabaseUrl = buildLocalSupabaseUrl(projectRoot);
+  const databaseUrl = buildLocalDatabaseUrl(projectRoot);
+  return {
+    // Database URLs
+    DATABASE_URL: databaseUrl,
+    DATABASE_URL_ADMIN: databaseUrl,
+    DATABASE_URL_SERVICE: databaseUrl,
+    // Supabase URLs and keys
+    NEXT_PUBLIC_SUPABASE_URL: supabaseUrl,
+    NEXT_PUBLIC_SUPABASE_ANON_KEY: LOCAL_SUPABASE_ANON_KEY,
+    SUPABASE_SERVICE_ROLE_KEY: LOCAL_SUPABASE_SERVICE_ROLE_KEY
+  };
+}
+function getLocalValueDescriptions(projectRoot = process.cwd()) {
+  const ports = detectLocalSupabasePorts(projectRoot);
+  return {
+    DATABASE_URL: `localhost:${ports.db} (PostgreSQL)`,
+    DATABASE_URL_ADMIN: `localhost:${ports.db} (PostgreSQL)`,
+    DATABASE_URL_SERVICE: `localhost:${ports.db} (PostgreSQL)`,
+    NEXT_PUBLIC_SUPABASE_URL: `localhost:${ports.api} (Supabase API)`,
+    NEXT_PUBLIC_SUPABASE_ANON_KEY: "local anon key (supabase-demo)",
+    SUPABASE_SERVICE_ROLE_KEY: "local service key (supabase-demo)"
+  };
+}
+var LOCAL_SUPABASE_ENV_VALUES = getLocalSupabaseEnvValues();
+getLocalValueDescriptions();
+function validateLocalhostValues(envValues) {
   const urlKeys = [
     "DATABASE_URL",
     "DATABASE_URL_ADMIN",
@@ -26241,7 +26224,7 @@ function validateLocalhostValues() {
   ];
   const invalidEntries = [];
   for (const key of urlKeys) {
-    const value = LOCAL_SUPABASE_ENV_VALUES[key];
+    const value = envValues[key];
     if (value && !value.includes("127.0.0.1") && !value.includes("localhost")) {
       invalidEntries.push(key);
     }
@@ -26252,7 +26235,7 @@ function validateLocalhostValues() {
     );
   }
 }
-validateLocalhostValues();
+validateLocalhostValues(LOCAL_SUPABASE_ENV_VALUES);
 
 // src/commands/env/commands/env-pull.ts
 var ERROR_MESSAGES3 = {
@@ -26496,10 +26479,14 @@ function replaceWithLocalValues(filePath, logger16, dryRun = false) {
     logger16.warn("  \u26A0\uFE0F  No valid env vars found in .env.development (check syntax)");
     return;
   }
+  const projectRoot = process.cwd();
+  const localEnvValues = getLocalSupabaseEnvValues(projectRoot);
+  const localDescriptions = getLocalValueDescriptions(projectRoot);
+  const replacementKeys = Object.keys(localEnvValues);
   const replacedKeys = [];
-  for (const key of LOCAL_REPLACEMENT_KEYS) {
-    if (key in parsed && LOCAL_SUPABASE_ENV_VALUES[key]) {
-      parsed[key] = LOCAL_SUPABASE_ENV_VALUES[key];
+  for (const key of replacementKeys) {
+    if (key in parsed && localEnvValues[key]) {
+      parsed[key] = localEnvValues[key];
       replacedKeys.push(key);
     }
   }
@@ -26518,7 +26505,7 @@ function replaceWithLocalValues(filePath, logger16, dryRun = false) {
   if (dryRun) {
     logger16.info(`  \u{1F3E0} Would replace ${replacedKeys.length} variables with localhost values:`);
     for (const key of replacedKeys) {
-      const description = LOCAL_VALUE_DESCRIPTIONS[key] || "localhost";
+      const description = localDescriptions[key] || "localhost";
       logger16.info(`     ${key} \u2192 ${description}`);
     }
     logger16.info("  (dry-run: no files modified)");
@@ -26528,7 +26515,7 @@ function replaceWithLocalValues(filePath, logger16, dryRun = false) {
 `, "utf-8");
   logger16.success(`  \u{1F3E0} Replaced ${replacedKeys.length} variables with localhost values:`);
   for (const key of replacedKeys) {
-    const description = LOCAL_VALUE_DESCRIPTIONS[key] || "localhost";
+    const description = localDescriptions[key] || "localhost";
     logger16.info(`     ${key} \u2192 ${description}`);
   }
 }
@@ -31133,7 +31120,7 @@ function buildDefinitionMap(definitions) {
 function buildEnhancedMachines(e2eManifest, definitionMap, machineDefinitions) {
   const enhanced = {};
   const normalizedIdToCanonical = /* @__PURE__ */ new Map();
-  const isMachineFile = (path63) => path63.includes("machine.ts") || path63.includes("machines/") || path63.includes(".machine.ts") || path63.includes("/machine/");
+  const isMachineFile = (path64) => path64.includes("machine.ts") || path64.includes("machines/") || path64.includes(".machine.ts") || path64.includes("/machine/");
   const addMachine = (id, sourceFile, entryBuilder) => {
     const normalizedId = normalizeToCanonicalId(id).toLowerCase();
     const existingCanonical = normalizedIdToCanonical.get(normalizedId);
@@ -32814,7 +32801,18 @@ var RUNA_ONLY_FILES = [
   "packages/database/scripts/check-plpgsql.ts",
   "packages/database/scripts/run-splinter.ts",
   "packages/database/scripts/seed-generators/index.ts",
+  "packages/database/scripts/seed-generators/loader.ts",
+  "packages/database/scripts/seed-generators/types.ts",
   "packages/database/scripts/seed-plugins/supabase-auth.ts",
+  "packages/database/scripts/seed-data-sources/api-source.ts",
+  "packages/database/scripts/seed-data-sources/csv-source.ts",
+  "packages/database/scripts/seed-data-sources/index.ts",
+  "packages/database/scripts/seed-data-sources/json-source.ts",
+  "packages/database/scripts/seed-data-sources/types.ts",
+  "packages/database/scripts/seed-hooks/index.ts",
+  "packages/database/scripts/seed-hooks/types.ts",
+  "packages/database/scripts/seed-utils/index.ts",
+  "packages/database/scripts/seed-utils/security.ts",
   // === runa-repo Specific Tests ===
   "packages/database/tests/00_system-schemas.sql",
   "packages/database/tests/01_table-helpers.sql",
@@ -33729,9 +33727,9 @@ var PATH_MAPPING_RULES = [
     category: "prompts"
   }
 ];
-function getCategoryForPath(path63) {
+function getCategoryForPath(path64) {
   for (const rule of PATH_MAPPING_RULES) {
-    if (matchGlobPattern(path63, rule.runa) || matchGlobPattern(path63, rule.template)) {
+    if (matchGlobPattern(path64, rule.runa) || matchGlobPattern(path64, rule.template)) {
       return rule.category;
     }
   }
@@ -33751,17 +33749,17 @@ function applyReverseRename(normalized, rule, isTemplate) {
   }
   return normalized;
 }
-function generateComparisonKey(path63, isTemplate) {
-  let normalized = isTemplate ? normalizeTemplatePath(path63) : path63;
+function generateComparisonKey(path64, isTemplate) {
+  let normalized = isTemplate ? normalizeTemplatePath(path64) : path64;
   for (const rule of PATH_MAPPING_RULES) {
     normalized = applyReverseRename(normalized, rule, isTemplate);
   }
   return normalized;
 }
-function matchGlobPattern(path63, pattern) {
+function matchGlobPattern(path64, pattern) {
   const regexPattern = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, "<<DOUBLE_STAR>>").replace(/\*/g, "([^/]*)").replace(/<<DOUBLE_STAR>>/g, "(.*)");
   const regex = new RegExp(`^${regexPattern}$`);
-  const match = path63.match(regex);
+  const match = path64.match(regex);
   if (match) {
     const subPath = match[1] ?? "";
     return { matched: true, subPath };
@@ -34123,7 +34121,7 @@ var syncCheckMachine = setup({
         onError: {
           target: "failed",
           actions: assign({
-            error: ({ event }) => `Discovery failed: ${getErrorMessage2(event.error)}`
+            error: ({ event }) => `Discovery failed: ${getErrorMessage(event.error)}`
           })
         }
       }
@@ -34150,7 +34148,7 @@ var syncCheckMachine = setup({
         onError: {
           target: "failed",
           actions: assign({
-            error: ({ event }) => `Comparison failed: ${getErrorMessage2(event.error)}`
+            error: ({ event }) => `Comparison failed: ${getErrorMessage(event.error)}`
           })
         }
       }
@@ -34174,7 +34172,7 @@ var syncCheckMachine = setup({
         onError: {
           target: "failed",
           actions: assign({
-            error: ({ event }) => `Report generation failed: ${getErrorMessage2(event.error)}`
+            error: ({ event }) => `Report generation failed: ${getErrorMessage(event.error)}`
           })
         }
       }
@@ -35733,7 +35731,7 @@ async function runVerification(logger16) {
 }
 async function findWorkspacesWithSdkPackages(rootDir, packageNames) {
   const fs14 = await import('fs/promises');
-  const path63 = await import('path');
+  const path64 = await import('path');
   const { glob: glob8 } = await import('glob');
   const result = [];
   const packageJsonPaths = await glob8("**/package.json", {
@@ -35742,7 +35740,7 @@ async function findWorkspacesWithSdkPackages(rootDir, packageNames) {
     // Exclude root
   });
   for (const relPath of packageJsonPaths) {
-    const fullPath = path63.join(rootDir, relPath);
+    const fullPath = path64.join(rootDir, relPath);
     try {
       const content = await fs14.readFile(fullPath, "utf-8");
       const pkg = JSON.parse(content);
@@ -35755,7 +35753,7 @@ async function findWorkspacesWithSdkPackages(rootDir, packageNames) {
       }
       if (hasAnySdkPackage) {
         result.push({
-          dir: path63.dirname(fullPath),
+          dir: path64.dirname(fullPath),
           packages: packageNames
           // All packages, not just found ones
         });
@@ -36398,7 +36396,7 @@ var SchemaWatcher = class {
       persistent: true,
       ignoreInitial: true
     });
-    this.watcher.on("add", (path63) => this.handleFileEvent("add", path63)).on("change", (path63) => this.handleFileEvent("change", path63)).on("unlink", (path63) => this.handleFileEvent("unlink", path63)).on("error", (error) => this.handleError(error));
+    this.watcher.on("add", (path64) => this.handleFileEvent("add", path64)).on("change", (path64) => this.handleFileEvent("change", path64)).on("unlink", (path64) => this.handleFileEvent("unlink", path64)).on("error", (error) => this.handleError(error));
     this.logger.success("\u2705 Schema watcher started");
     this.logger.info(chalk.dim("  Press Ctrl+C to stop\n"));
   }
@@ -36419,23 +36417,23 @@ var SchemaWatcher = class {
   /**
    * Handle file system events with debouncing
    */
-  handleFileEvent(type, path63) {
-    const existingTimer = this.debounceTimers.get(path63);
+  handleFileEvent(type, path64) {
+    const existingTimer = this.debounceTimers.get(path64);
     if (existingTimer) {
       clearTimeout(existingTimer);
     }
     const timer = setTimeout(() => {
-      this.processFileEvent({ type, path: path63, timestamp: /* @__PURE__ */ new Date() });
-      this.debounceTimers.delete(path63);
+      this.processFileEvent({ type, path: path64, timestamp: /* @__PURE__ */ new Date() });
+      this.debounceTimers.delete(path64);
     }, this.options.debounceMs);
-    this.debounceTimers.set(path63, timer);
+    this.debounceTimers.set(path64, timer);
   }
   /**
    * Process file system event
    */
   async processFileEvent(event) {
-    const { type, path: path63 } = event;
-    const fileName = path63.split("/").pop() || path63;
+    const { type, path: path64 } = event;
+    const fileName = path64.split("/").pop() || path64;
     switch (type) {
       case "add":
         this.logger.info(chalk.green(`\u2795 Added: ${fileName}`));
@@ -36448,19 +36446,19 @@ var SchemaWatcher = class {
         return;
     }
     if (this.options.autoValidate) {
-      await this.validateFile(path63);
+      await this.validateFile(path64);
     }
   }
   /**
    * Validate schema file
    */
-  async validateFile(path63) {
+  async validateFile(path64) {
     try {
       this.logger.info(chalk.dim("  Validating..."));
-      const validationResult = await validateSchemaFile(path63);
+      const validationResult = await validateSchemaFile(path64);
       if (validationResult.isValid) {
         this.logger.success(chalk.green("  \u2713 Validation passed"));
-        const risks = await detectSchemaRisks(path63);
+        const risks = await detectSchemaRisks(path64);
         if (risks.length > 0) {
           this.logger.warn(`  \u26A0\uFE0F  ${risks.length} risk(s) detected`);
           for (const risk of risks) {
@@ -36475,7 +36473,7 @@ var SchemaWatcher = class {
         if (this.options.notifyOnError) {
           await notifyDesktop({
             title: "Schema Validation Failed",
-            message: `${validationResult.errors.length} error(s) in ${path63.split("/").pop()}`,
+            message: `${validationResult.errors.length} error(s) in ${path64.split("/").pop()}`,
             type: "error"
           });
         }
@@ -36694,7 +36692,7 @@ var TestWatcher = class {
       persistent: true,
       ignoreInitial: true
     });
-    this.watcher.on("add", (path63) => this.handleFileEvent("add", path63)).on("change", (path63) => this.handleFileEvent("change", path63)).on("unlink", (path63) => this.handleFileEvent("unlink", path63)).on("error", (error) => this.handleError(error));
+    this.watcher.on("add", (path64) => this.handleFileEvent("add", path64)).on("change", (path64) => this.handleFileEvent("change", path64)).on("unlink", (path64) => this.handleFileEvent("unlink", path64)).on("error", (error) => this.handleError(error));
     this.logger.success("\u2705 Test watcher started");
     this.logger.info(chalk.dim("  Press Ctrl+C to stop\n"));
   }
@@ -36715,26 +36713,26 @@ var TestWatcher = class {
   /**
    * Handle file system events with debouncing
    */
-  handleFileEvent(type, path63) {
-    const existingTimer = this.debounceTimers.get(path63);
+  handleFileEvent(type, path64) {
+    const existingTimer = this.debounceTimers.get(path64);
     if (existingTimer) {
       clearTimeout(existingTimer);
     }
     const timer = setTimeout(() => {
-      this.processFileEvent(type, path63);
-      this.debounceTimers.delete(path63);
+      this.processFileEvent(type, path64);
+      this.debounceTimers.delete(path64);
     }, this.options.debounceMs);
-    this.debounceTimers.set(path63, timer);
+    this.debounceTimers.set(path64, timer);
   }
   /**
    * Process file system event
    */
-  async processFileEvent(type, path63) {
+  async processFileEvent(type, path64) {
     if (this.isRunning) {
       this.logger.warn(chalk.yellow("\u23F3 Tests already running, skipping..."));
       return;
     }
-    const fileName = path63.split("/").pop() || path63;
+    const fileName = path64.split("/").pop() || path64;
     switch (type) {
       case "add":
         this.logger.info(chalk.green(`\u2795 Test added: ${fileName}`));
@@ -36747,7 +36745,7 @@ var TestWatcher = class {
         return;
     }
     if (this.options.autoRun) {
-      await this.runTests(path63);
+      await this.runTests(path64);
     }
   }
   /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@runa-ai/runa-cli",
-  "version": "0.5.44",
+  "version": "0.5.46",
   "private": false,
   "description": "AI-powered DevOps CLI",
   "type": "module",