@runa-ai/runa-cli 0.6.0 → 0.7.1

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

@@ -0,0 +1,77 @@
+/**
+ * AI HINT: Canonical schema snapshot + semantic diff
+ *
+ * Purpose: Detect schema drift beyond simple T/F/P/I counts.
+ * Pattern: Normalize PostgreSQL catalog metadata into stable signatures.
+ *
+ * Detects semantic differences in:
+ * - Tables (columns, constraints, RLS flags)
+ * - Functions (signature, language, volatility, security, body)
+ * - Policies (command, roles, USING / WITH CHECK)
+ * - Indexes (definition, uniqueness, predicate)
+ * - Triggers (definition)
+ */
+export type CanonicalSchemaObjectKind = 'table' | 'function' | 'policy' | 'index' | 'trigger';
+export interface CanonicalSchemaObject {
+    kind: CanonicalSchemaObjectKind;
+    schema: string;
+    name: string;
+    key: string;
+    label: string;
+    parentName?: string;
+    signature: string;
+}
+export interface CanonicalSchemaSnapshot {
+    available: boolean;
+    objects: CanonicalSchemaObject[];
+    error?: string;
+}
+export interface CanonicalSchemaObjectPair {
+    reference: CanonicalSchemaObject;
+    target: CanonicalSchemaObject;
+}
+export interface CanonicalSchemaDiff {
+    missing: CanonicalSchemaObject[];
+    extra: CanonicalSchemaObject[];
+    changed: CanonicalSchemaObjectPair[];
+    renamed: CanonicalSchemaObjectPair[];
+}
+export interface SchemaSemanticSummary {
+    hasChanges: boolean;
+    changedKinds: CanonicalSchemaObjectKind[];
+    counts: {
+        missing: number;
+        extra: number;
+        changed: number;
+        renamed: number;
+    };
+}
+export type CanonicalDiffBySchema = Record<string, SchemaSemanticSummary>;
+export declare function createUnavailableCanonicalSnapshot(error: string): CanonicalSchemaSnapshot;
+interface TableColumnRow {
+    schema_name: string;
+    table_name: string;
+    attnum: number;
+    column_name: string;
+    data_type: string;
+    not_null: boolean;
+    default_expr?: string | null;
+    identity_kind?: string | null;
+    generated_kind?: string | null;
+}
+interface CanonicalTableColumnPayload {
+    name: string;
+    type: string;
+    notNull: boolean;
+    default: string;
+    identity: string;
+    generated: string;
+}
+export declare function createCanonicalTableColumnPayload(row: Pick<TableColumnRow, 'column_name' | 'data_type' | 'not_null' | 'default_expr' | 'identity_kind' | 'generated_kind'>): CanonicalTableColumnPayload;
+export declare function sortCanonicalTableColumns(columns: readonly CanonicalTableColumnPayload[]): CanonicalTableColumnPayload[];
+export declare function getCanonicalSchemaSnapshot(databaseUrl: string): Promise<CanonicalSchemaSnapshot>;
+export declare function compareCanonicalSnapshots(reference: CanonicalSchemaSnapshot, target: CanonicalSchemaSnapshot): CanonicalSchemaDiff;
+export declare function summarizeCanonicalDiffBySchema(diff: CanonicalSchemaDiff): CanonicalDiffBySchema;
+export declare function hasCanonicalChanges(diff: CanonicalSchemaDiff): boolean;
+export {};
+//# sourceMappingURL=schema-canonical-diff.d.ts.map

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

@@ -32,6 +32,7 @@
  * - Supabase platform functions: supabase_* (not extension-owned)
  * - PostgREST platform functions: postgrest_*, pgrst_*, _pgrst_* (not extension-owned)
  */
+import type { CanonicalSchemaSnapshot } from './schema-canonical-diff.js';
 /**
  * Statistics for a single schema.
  */
@@ -59,6 +60,10 @@ export interface IndexInfo {
     isPartial: boolean;
     /** WHERE clause for partial indexes (e.g., 'check_run_id IS NOT NULL') */
     whereClause?: string;
+    /** Access method (e.g., btree, gin) */
+    accessMethod?: string;
+    /** Normalized index definition for semantic comparison */
+    definition?: string;
 }
 /**
  * Statistics for all schemas in an environment.
@@ -70,6 +75,12 @@ export interface EnvironmentSchemaStats {
     total: SchemaStats;
     /** Detailed index list for diff detection (optional for backward compatibility) */
     indexList?: IndexInfo[];
+    /** Canonical snapshot for semantic diff detection */
+    canonicalSnapshot?: CanonicalSchemaSnapshot;
+    /** False when stats collection failed and counts should not be trusted */
+    available?: boolean;
+    /** Collection error summary for degraded display */
+    error?: string;
 }
 /**
  * Snapshot of schema statistics across all environments.

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

@@ -25,7 +25,7 @@
  * - Captures hazards from pg-schema-diff
  * - Reports all changes in PR comment
  */
-import type { CiMode, SchemaDriftSnapshot } from '../../types.js';
+import type { CiMode, SchemaChangeStats, SchemaDriftSnapshot } from '../../types.js';
 export interface SyncSchemaInput {
     repoRoot: string;
     tmpDir: string;
@@ -38,6 +38,14 @@ export interface SyncSchemaOutput {
     error?: string;
     schemaDrift?: SchemaDriftSnapshot;
 }
+export declare function analyzePostCheckResult(params: {
+    exitCode: number;
+    output: string;
+    residualStats: SchemaChangeStats;
+}): {
+    hasDrift: boolean;
+    commandFailed: boolean;
+};
 /**
  * Sync database schema using runa db sync.
  * ALWAYS applies changes - NO dry-run mode in CI.

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

@@ -10,8 +10,10 @@
  * - Fire-and-forget pattern (non-blocking)
  */
 import type { CLILogger } from '@runa-ai/runa';
+import { type CiStep } from '../formatters/github-comment.js';
 import { type CiSnapshot } from '../machine.js';
 import type { CiInput, CiOutput, LayerResult } from '../types.js';
+export declare function resolveStepForState(state: string): CiStep | undefined;
 /**
  * State change callback type.
  */

package/dist/commands/ci/machine/formatters/sections/production-schema-status.d.ts

@@ -0,0 +1,30 @@
+import { type ExpectedDriftEntry, type IndexDiff, type SchemaStats, type SchemaStatsSnapshot } from '../../actors/db/schema-stats.js';
+import { type CanonicalSchemaDiff } from '../../actors/db/schema-canonical-diff.js';
+import type { ProductionPreview } from '../../types.js';
+export interface ProductionSchemaSignals {
+    previewHasChanges: boolean;
+    indexDiff: IndexDiff | null;
+    semanticDiff: CanonicalSchemaDiff | null;
+    countDiffs: CountDiffEntry[];
+    hasIndexChanges: boolean;
+    hasUnexpectedIndexChanges: boolean;
+    hasSemanticChanges: boolean;
+    hasCountChanges: boolean;
+    hasUnexpectedCountChanges: boolean;
+    hasKnownDriftOnly: boolean;
+    knownDriftReasons: string[];
+    requiresDeploy: boolean;
+    previewMissedChanges: boolean;
+    previewOnlyChanges: boolean;
+}
+export interface CountDiffEntry {
+    schema: string;
+    field: keyof SchemaStats;
+    value: number;
+    reference: number;
+    delta: number;
+    expected: boolean;
+    reason?: string;
+}
+export declare function getProductionSchemaSignals(productionPreview: ProductionPreview | null, schemaStats: SchemaStatsSnapshot | null, expectedDrift?: ExpectedDriftEntry[]): ProductionSchemaSignals;
+//# sourceMappingURL=production-schema-status.d.ts.map

package/dist/commands/ci/machine/formatters/sections/schema-matrix.d.ts

@@ -5,13 +5,13 @@
  * Pattern: Pure function - takes schema stats, returns markdown lines
  *
  * Output format (includes I for Indexes, with diff highlighting):
- * | Schema | 📄 Local | 🔬 CI | 🏭 Prod |
+ * | Schema | 📄 Reference | 🔬 CI | 🏭 Prod |
  * |--------|:--------:|:-----:|:-------:|
  * | accounts | 5T 3F 12P 3I | 5T 3F 12P 3I | 📝 5T 3F 12P **2I** |
  *
  * Diff highlighting:
- * - ⚠️ = CI differs from Local (SSOT) - unexpected
- * - 📝 = Prod differs from Local (schema changes pending)
+ * - ⚠️ = CI differs from Reference (count diff or semantic diff)
+ * - 📝 = Prod differs from Reference (count diff or semantic diff)
  * - 📋 = Known drift (matches expectedDrift config)
  * - **bold** = specific field that differs
  */

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

@@ -29,6 +29,14 @@ export declare function getLayersForCorePhase(selectedLayers: number[], mode: st
  * Check if E2E layer (4) is selected.
  */
 export declare function hasE2ELayer(selectedLayers: number[]): boolean;
+/**
+ * Determine whether schema stats can safely reuse the synced CI database
+ * instead of rebuilding a temporary reference database.
+ *
+ * This optimization is only valid for PR CI runs where local-only overlays
+ * such as ci.custom.sql are never applied.
+ */
+export declare function shouldReuseCiReferenceStats(context: CiContext): boolean;
 /** Layer result status type */
 export type LayerStatus = 'passed' | 'failed' | 'skipped' | 'timeout' | 'killed';
 /**

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

@@ -8,9 +8,10 @@
  * 1. idle → START → setup (mode-aware: localSetup or prLocalSetup)
  * 2. [ci-local] setup → dbReset → pullProduction? → syncSchema → applySeeds
  *              → productionPreview → collectSchemaStats → installPgTap → runCoreTests → done
- * 3. [ci-pr] setup → initialComment → syncSchema → applySeeds → productionPreview
- *           → collectSchemaStats → setupRoles → staticChecks → buildAndPlaywright
- *           → appStart → capabilities → runCoreTests → e2ePhase → finalize → done
+ * 3. [ci-pr] setup → initialComment → syncSchema → applySeeds → postSeedPr
+ *           execution: setupRoles → staticChecks → buildAndPlaywright → appStart
+ *                    → capabilities → runCoreTests → e2ePhase → finalize → done
+ *           observability: productionPreview ∥ collectSchemaStats
  *
  * State Flow (detailed):
  *   idle → setup → initialComment? → dbReset? → pullProduction? → syncSchema → applySeeds
@@ -168,10 +169,20 @@ export declare const ciMachine: import("xstate").StateMachine<CiContext, CiEvent
 } | {
     type: "allTestsPassed";
     params: unknown;
-}, never, "done" | "failed" | "staticChecks" | "idle" | "capabilities" | "appStart" | "syncSchema" | "applySeeds" | "productionPreview" | "pullProduction" | "collectSchemaStats" | "setupRoles" | "installPgTap" | "buildAndPlaywright" | "initialComment" | "dbReset" | "decidePath" | "runCoreTests" | "coreTestsFailed" | "coreTestsComplete" | {
+}, never, "done" | "failed" | "staticChecks" | "idle" | "capabilities" | "appStart" | "syncSchema" | "applySeeds" | "productionPreview" | "pullProduction" | "collectSchemaStats" | "setupRoles" | "installPgTap" | "buildAndPlaywright" | "initialComment" | "dbReset" | "runCoreTests" | "coreTestsFailed" | "coreTestsComplete" | "decidePath" | {
     setup: "local" | "resolving" | "prLocal" | "complete";
 } | {
     finalize: "writeSummary" | "complete" | "postComment";
+} | {
+    postSeedPr: {
+        execution: "done" | "failed" | "staticChecks" | "capabilities" | "appStart" | "setupRoles" | "buildAndPlaywright" | "runCoreTests" | "coreTestsFailed" | "coreTestsComplete" | {
+            e2ePhase: {
+                intermediateComment: "done" | "checking" | "posting";
+                e2eTests: "done" | "running";
+            };
+        };
+        observability: "done" | "productionPreview" | "collectSchemaStats";
+    };
 } | {
     e2ePhase: {
         intermediateComment: "done" | "checking" | "posting";
@@ -257,6 +268,48 @@ export declare const ciMachine: import("xstate").StateMachine<CiContext, CiEvent
         readonly pullProduction: {};
         readonly syncSchema: {};
         readonly applySeeds: {};
+        readonly postSeedPr: {
+            states: {
+                readonly execution: {
+                    states: {
+                        readonly setupRoles: {};
+                        readonly staticChecks: {};
+                        readonly buildAndPlaywright: {};
+                        readonly appStart: {};
+                        readonly capabilities: {};
+                        readonly runCoreTests: {};
+                        readonly coreTestsComplete: {};
+                        readonly coreTestsFailed: {};
+                        readonly e2ePhase: {
+                            states: {
+                                readonly intermediateComment: {
+                                    states: {
+                                        readonly checking: {};
+                                        readonly posting: {};
+                                        readonly done: {};
+                                    };
+                                };
+                                readonly e2eTests: {
+                                    states: {
+                                        readonly running: {};
+                                        readonly done: {};
+                                    };
+                                };
+                            };
+                        };
+                        readonly failed: {};
+                        readonly done: {};
+                    };
+                };
+                readonly observability: {
+                    states: {
+                        readonly productionPreview: {};
+                        readonly collectSchemaStats: {};
+                        readonly done: {};
+                    };
+                };
+            };
+        };
         readonly productionPreview: {};
         readonly collectSchemaStats: {};
         readonly decidePath: {};

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

@@ -73,6 +73,8 @@ export interface SchemaDriftSnapshot {
     beforeSql: string | null;
     /** SQL preview (may be truncated) from check-after */
     afterSql: string | null;
+    /** Whether a post-apply check was executed */
+    checkExecuted: boolean;
     /** True if check-after indicates remaining changes (drift) */
     hasDrift: boolean;
     /** Schema change statistics (parsed from beforeSql) */

package/dist/commands/ci/utils/execa-helpers.d.ts

@@ -15,5 +15,6 @@ export declare function runLogged(params: {
     args: string[];
     logFile: string;
     timeoutMs?: number;
+    reject?: boolean;
 }): ResultPromise;
 //# sourceMappingURL=execa-helpers.d.ts.map

package/dist/commands/db/commands/db-sync/error-classifier.d.ts

@@ -0,0 +1,9 @@
+import { type RunaDbEnv } from '../../utils/db-target.js';
+export interface DbSyncCommandFailure {
+    code: string;
+    message: string;
+    suggestions: string[];
+}
+export declare function classifyDbSyncCommandFailure(error: unknown, environment: RunaDbEnv): DbSyncCommandFailure | null;
+export declare function getDbSyncFallbackSuggestions(): string[];
+//# sourceMappingURL=error-classifier.d.ts.map

package/dist/commands/dev/actors/index.d.ts

@@ -7,11 +7,16 @@
  * - depsInstallActor: Check/install dependencies
  * - envCheckActor: Check environment variables
  * - supabaseStartActor: Start Supabase local
+ * - tablesManifestActor: Refresh tables.json from local Supabase
  * - processCheckActor: Check for existing processes and port availability
  * - appStartActor: Start Next.js dev server
  * - shutdownActor: Gracefully shut down dev server
  */
 export { depsInstallActor, envCheckActor, supabaseStartActor, } from '../../build/actors/setup.js';
+export { manifestActor } from '../../build/actors/manifest.js';
+export type { ManifestInput, ManifestOutput } from '../../build/actors/manifest.js';
+export { tablesManifestActor } from './tables-manifest.js';
+export type { TablesManifestInput, TablesManifestOutput } from './tables-manifest.js';
 export { processCheckActor } from './process-check.js';
 export type { ProcessCheckInput, ProcessCheckOutput } from './process-check.js';
 export { appStartActor, shutdownActor } from './app-lifecycle.js';

package/dist/commands/dev/actors/tables-manifest.d.ts

@@ -0,0 +1,16 @@
+/**
+ * AI HINT: Tables Manifest Refresh Actor
+ *
+ * Purpose: Refresh .runa/manifests/tables.json from the local Supabase database
+ * Pattern: Lightweight introspection refresh for `runa dev`
+ */
+export interface TablesManifestInput {
+    repoRoot: string;
+}
+export interface TablesManifestOutput {
+    passed: boolean;
+    durationMs: number;
+    error?: string;
+}
+export declare const tablesManifestActor: import("xstate").PromiseActorLogic<TablesManifestOutput, TablesManifestInput, import("xstate").EventObject>;
+//# sourceMappingURL=tables-manifest.d.ts.map

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

@@ -22,8 +22,8 @@ export declare const DevInputSchema: z.ZodObject<{
     targetDir: z.ZodOptional<z.ZodString>;
     replace: z.ZodDefault<z.ZodBoolean>;
     bundler: z.ZodOptional<z.ZodEnum<{
-        turbopack: "turbopack";
         webpack: "webpack";
+        turbopack: "turbopack";
     }>>;
 }, z.core.$strict>;
 export type DevInput = z.infer<typeof DevInputSchema>;

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

@@ -18,9 +18,33 @@ export declare function shouldSkipDb({ context }: GuardParams): boolean;
  * Skipped when --skip-app is specified.
  */
 export declare function shouldSkipApp({ context }: GuardParams): boolean;
+/**
+ * Check if manifest generation should be skipped.
+ * Skipped when app startup is disabled or manifest generation is not applicable.
+ */
+export declare function shouldSkipManifest({ context }: GuardParams): boolean;
+/**
+ * Check if tables manifest refresh should be skipped.
+ * Skipped when app startup is disabled, DB setup is disabled, or Supabase is unavailable.
+ */
+export declare function shouldSkipTablesManifest({ context }: GuardParams): boolean;
+/**
+ * Check if an actor phase reported a failed result.
+ */
+export declare function phaseFailed({ event, }: {
+    event: {
+        output?: {
+            passed?: boolean;
+        };
+        [key: string]: unknown;
+    };
+}): boolean;
 export declare const guards: {
     shouldSkipDb: typeof shouldSkipDb;
     shouldSkipApp: typeof shouldSkipApp;
+    shouldSkipManifest: typeof shouldSkipManifest;
+    shouldSkipTablesManifest: typeof shouldSkipTablesManifest;
+    phaseFailed: typeof phaseFailed;
 };
 export {};
 //# sourceMappingURL=guards.d.ts.map

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

@@ -11,7 +11,7 @@
  *
  * State Flow:
  * idle → START → processCheck → setup{depsInstall → envCheck → supabaseStart}
- *   → appStart → running → (STOP) → shutdown → done
+ *   → tablesManifest → manifest → appStart → running → (STOP) → shutdown → done
  * Any error → failed
  *
  * E2E Test Mapping (CLI observable behavior):
@@ -38,8 +38,12 @@ export declare const devMachine: import("xstate").StateMachine<DevContext, {
     type: "error.platform";
     error: Error;
 }, {
-    [x: string]: import("xstate").ActorRefFromLogic<import("xstate").PromiseActorLogic<import("../build/actors/setup.js").DepsInstallOutput, import("../build/actors/setup.js").SetupInput, import("xstate").EventObject>> | import("xstate").ActorRefFromLogic<import("xstate").PromiseActorLogic<import("../build/actors/setup.js").EnvCheckOutput, import("../build/actors/setup.js").SetupInput, import("xstate").EventObject>> | import("xstate").ActorRefFromLogic<import("xstate").PromiseActorLogic<import("../build/actors/setup.js").SupabaseStartOutput, import("../build/actors/setup.js").SetupInput, import("xstate").EventObject>> | import("xstate").ActorRefFromLogic<import("xstate").PromiseActorLogic<ProcessCheckOutput, import("./actors/process-check.js").ProcessCheckInput, import("xstate").EventObject>> | import("xstate").ActorRefFromLogic<import("xstate").PromiseActorLogic<import("./actors/app-lifecycle.js").AppStartOutput, import("./actors/app-lifecycle.js").AppStartInput, import("xstate").EventObject>> | import("xstate").ActorRefFromLogic<import("xstate").PromiseActorLogic<void, import("./actors/app-lifecycle.js").ShutdownInput, import("xstate").EventObject>> | undefined;
+    [x: string]: import("xstate").ActorRefFromLogic<import("xstate").PromiseActorLogic<import("./actors/index.js").ManifestOutput, import("./actors/index.js").ManifestInput, import("xstate").EventObject>> | import("xstate").ActorRefFromLogic<import("xstate").PromiseActorLogic<import("../build/actors/setup.js").DepsInstallOutput, import("../build/actors/setup.js").SetupInput, import("xstate").EventObject>> | import("xstate").ActorRefFromLogic<import("xstate").PromiseActorLogic<import("../build/actors/setup.js").EnvCheckOutput, import("../build/actors/setup.js").SetupInput, import("xstate").EventObject>> | import("xstate").ActorRefFromLogic<import("xstate").PromiseActorLogic<import("../build/actors/setup.js").SupabaseStartOutput, import("../build/actors/setup.js").SetupInput, import("xstate").EventObject>> | import("xstate").ActorRefFromLogic<import("xstate").PromiseActorLogic<ProcessCheckOutput, import("./actors/process-check.js").ProcessCheckInput, import("xstate").EventObject>> | import("xstate").ActorRefFromLogic<import("xstate").PromiseActorLogic<import("./actors/app-lifecycle.js").AppStartOutput, import("./actors/app-lifecycle.js").AppStartInput, import("xstate").EventObject>> | import("xstate").ActorRefFromLogic<import("xstate").PromiseActorLogic<void, import("./actors/app-lifecycle.js").ShutdownInput, import("xstate").EventObject>> | import("xstate").ActorRefFromLogic<import("xstate").PromiseActorLogic<import("./actors/tables-manifest.js").TablesManifestOutput, import("./actors/tables-manifest.js").TablesManifestInput, import("xstate").EventObject>> | undefined;
 }, {
+    src: "manifest";
+    logic: import("xstate").PromiseActorLogic<import("./actors/index.js").ManifestOutput, import("./actors/index.js").ManifestInput, import("xstate").EventObject>;
+    id: string | undefined;
+} | {
     src: "depsInstall";
     logic: import("xstate").PromiseActorLogic<import("../build/actors/setup.js").DepsInstallOutput, import("../build/actors/setup.js").SetupInput, import("xstate").EventObject>;
     id: string | undefined;
@@ -63,13 +67,26 @@ export declare const devMachine: import("xstate").StateMachine<DevContext, {
     src: "shutdown";
     logic: import("xstate").PromiseActorLogic<void, import("./actors/app-lifecycle.js").ShutdownInput, import("xstate").EventObject>;
     id: string | undefined;
+} | {
+    src: "tablesManifest";
+    logic: import("xstate").PromiseActorLogic<import("./actors/tables-manifest.js").TablesManifestOutput, import("./actors/tables-manifest.js").TablesManifestInput, import("xstate").EventObject>;
+    id: string | undefined;
 }, never, {
     type: "shouldSkipDb";
     params: unknown;
+} | {
+    type: "shouldSkipManifest";
+    params: unknown;
 } | {
     type: "shouldSkipApp";
     params: unknown;
-}, never, "done" | "failed" | "running" | "idle" | "processCheck" | "appStart" | "shutdown" | {
+} | {
+    type: "shouldSkipTablesManifest";
+    params: unknown;
+} | {
+    type: "phaseFailed";
+    params: unknown;
+}, never, "done" | "failed" | "manifest" | "running" | "idle" | "processCheck" | "appStart" | "shutdown" | "tablesManifest" | {
     setup: "done" | "depsInstall" | "envCheck" | "supabaseStart";
 }, string, DevMachineInput, {
     success: boolean;
@@ -90,6 +107,8 @@ export declare const devMachine: import("xstate").StateMachine<DevContext, {
                 readonly done: {};
             };
         };
+        readonly tablesManifest: {};
+        readonly manifest: {};
         readonly appStart: {};
         readonly running: {};
         readonly shutdown: {};

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

@@ -20,6 +20,8 @@ export interface DevContext {
     tmpDir: string;
     /** Whether Supabase is configured */
     hasDatabase: boolean;
+    /** Whether manifest generation is applicable */
+    hasManifestTask: boolean;
     /** App process PID (when running) */
     appPid: number | null;
     /** Whether Supabase was started */

package/dist/commands/doctor.d.ts

@@ -0,0 +1,9 @@
+/**
+ * AI HINT: runa doctor
+ *
+ * Purpose: Deprecated alias for `runa check`
+ * Contract: JSON output must match `runa check`
+ */
+import { Command } from 'commander';
+export declare const doctorCommand: Command;
+//# sourceMappingURL=doctor.d.ts.map

package/dist/commands/inject-test-attrs/defaults.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Shared default file discovery patterns for manifest generation.
+ *
+ * These defaults intentionally cover both monorepo layouts and common single-app layouts.
+ * The processor still filters files later, so broader discovery is preferred over silent misses.
+ */
+export declare const DEFAULT_INCLUDE_PATTERNS: readonly ["app/**/*.tsx", "app/**/*.ts", "pages/**/*.tsx", "pages/**/*.ts", "src/**/*.tsx", "src/**/*.ts", "components/**/*.tsx", "components/**/*.ts", "hooks/**/*.tsx", "hooks/**/*.ts", "lib/**/*.tsx", "lib/**/*.ts", "machines/**/*.tsx", "machines/**/*.ts", "features/**/*.tsx", "features/**/*.ts", "modules/**/*.tsx", "modules/**/*.ts", "domain/**/*.tsx", "domain/**/*.ts", "screens/**/*.tsx", "screens/**/*.ts", "views/**/*.tsx", "views/**/*.ts", "routes/**/*.tsx", "routes/**/*.ts", "api/**/*.tsx", "api/**/*.ts", "server/**/*.tsx", "server/**/*.ts", "apps/**/*.tsx", "apps/**/*.ts", "packages/**/*.tsx", "packages/**/*.ts"];
+export declare const DEFAULT_EXCLUDE_PATTERNS: readonly ["**/node_modules/**", "**/.next/**", "**/dist/**", "**/*.test.*", "**/*.spec.*", "**/*.stories.*"];
+//# sourceMappingURL=defaults.d.ts.map

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

@@ -9,6 +9,7 @@
  * - runa template-check --verbose          # Show all files including identical
  * - runa template-check --diff             # Show unified diff for differences
  * - runa template-check --category rules   # Filter by category
+ * - runa template-check --path <file>      # Restrict to specific paths
  * - runa template-check --json             # Output as JSON (for CI)
  * - runa template-check --quiet            # Only summary + actions (for pre-commit)
  */

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

@@ -17,6 +17,7 @@ export declare const SyncCheckInputSchema: z.ZodObject<{
     verbose: z.ZodDefault<z.ZodBoolean>;
     diff: z.ZodDefault<z.ZodBoolean>;
     category: z.ZodOptional<z.ZodString>;
+    paths: z.ZodOptional<z.ZodArray<z.ZodString>>;
     json: z.ZodDefault<z.ZodBoolean>;
     targetDir: z.ZodOptional<z.ZodString>;
     quiet: z.ZodDefault<z.ZodBoolean>;

package/dist/commands/utils/machine-state-logging.d.ts

@@ -0,0 +1,20 @@
+import type { CLILogger } from '@runa-ai/runa';
+export type MachineStateLoggerArgOrder = 'logger-first' | 'context-first';
+export type MachineStateLogger<TContext, TExtra = undefined, TOrder extends MachineStateLoggerArgOrder = 'logger-first'> = TOrder extends 'context-first' ? (context: TContext, logger: CLILogger, extra?: TExtra) => void : (logger: CLILogger, context: TContext, extra?: TExtra) => void;
+type MachineStateChangeLoggerOptionsBase<TSnapshot, TContext, TExtra = undefined, TOrder extends MachineStateLoggerArgOrder = 'logger-first'> = {
+    getState: (snapshot: TSnapshot) => string;
+    getContext: (snapshot: TSnapshot) => TContext;
+    handlers: Record<string, MachineStateLogger<TContext, TExtra, TOrder>>;
+    useParentState?: boolean;
+    shouldSkipState?: (state: string, prevState: string, context: TContext, extra: TExtra | undefined) => boolean;
+    onUnknownState?: (state: string, logger: CLILogger, context: TContext, extra: TExtra | undefined, prevState: string) => void;
+    handlerArgumentOrder?: MachineStateLoggerArgOrder;
+};
+export type MachineStateChangeLoggerOptions<TSnapshot, TContext, TExtra = undefined, TOrder extends MachineStateLoggerArgOrder = 'logger-first'> = MachineStateChangeLoggerOptionsBase<TSnapshot, TContext, TExtra, TOrder> & (TOrder extends 'context-first' ? {
+    handlerArgumentOrder: 'context-first';
+} : {
+    handlerArgumentOrder?: 'logger-first';
+});
+export declare function createMachineStateChangeLogger<TSnapshot, TContext, TExtra = undefined, TOrder extends MachineStateLoggerArgOrder = 'logger-first'>(options: MachineStateChangeLoggerOptions<TSnapshot, TContext, TExtra, TOrder>): (snapshot: TSnapshot, prevState: string, logger: CLILogger, extra?: TExtra) => void;
+export {};
+//# sourceMappingURL=machine-state-logging.d.ts.map

package/dist/commands/utils/repo-root.d.ts

@@ -0,0 +1,2 @@
+export declare function findRepoRoot(startDir: string): string;
+//# sourceMappingURL=repo-root.d.ts.map

package/dist/constants/versions.d.ts

@@ -20,7 +20,7 @@
  *
  * Sync strategy: Keep this in sync with packages/runa-templates/package.json version.
  */
-export declare const COMPATIBLE_TEMPLATES_VERSION = "0.5.71";
+export declare const COMPATIBLE_TEMPLATES_VERSION = "0.7.1";
 /**
  * Templates package name on GitHub Packages.
  * Published to npm.pkg.github.com (requires NODE_AUTH_TOKEN).