@runa-ai/runa-cli 0.7.0 → 0.7.1

package/dist/{ci-ZWRVWNFX.js → ci-XY6IKEDC.js}

@@ -1,11 +1,11 @@
 #!/usr/bin/env node
 import { createRequire } from 'module';
-import { normalizeDatabaseUrlForDdl, enhanceConnectionError, parseBoolish, detectAppSchemas, formatSchemasForSql } from './chunk-XDCHRVE3.js';
+import { normalizeDatabaseUrlForDdl, parseBoolish, enhanceConnectionError, detectAppSchemas, formatSchemasForSql } from './chunk-XDCHRVE3.js';
 import { isPathContained } from './chunk-DRSUEMAK.js';
 import './chunk-QDF7QXBL.js';
-import { getSnapshotStateName, isSnapshotComplete } from './chunk-IBVVGH6X.js';
+import { getSnapshotStateName, isSnapshotComplete } from './chunk-EMB6IZFT.js';
 import { writeEnvLocal, startAppBackground, waitForAppReady, executePrSetupBase, createErrorOutput } from './chunk-HD74F6W2.js';
-import { psqlSyncQuery, parsePostgresUrl, buildPsqlArgs, buildPsqlEnv } from './chunk-7B5C6U2K.js';
+import { parsePostgresUrl, buildPsqlArgs, buildPsqlEnv, psqlSyncQuery } from './chunk-7B5C6U2K.js';
 import { ensureRunaTmpDir, runLogged } from './chunk-6FAU4IGR.js';
 import { createMachineStateChangeLogger } from './chunk-5FT3F36G.js';
 import { getSafeEnv, getFilteredEnv, redactSecrets } from './chunk-II7VYQEM.js';
@@ -1884,24 +1884,41 @@ var ciProdApplyCommand = new Command("prod-apply").description("Apply production
 
 // src/commands/ci/commands/ci-static.ts
 init_esm_shims();
-function getChecks() {
-  return [
-    {
+function hasNativeActionlint() {
+  try {
+    const result = spawnSync("actionlint", ["-version"], {
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "pipe"],
+      timeout: 5e3
+    });
+    return result.status === 0;
+  } catch {
+    return false;
+  }
+}
+function createActionlintCheck(mode) {
+  if (mode === "local" && hasNativeActionlint()) {
+    return {
       name: "actionlint",
       label: "Workflow Lint",
       description: "GitHub Actions syntax validation",
-      command: "docker",
-      args: [
-        "run",
-        "--rm",
-        "-v",
-        `${process.cwd()}:/repo`,
-        "-w",
-        "/repo",
-        "rhysd/actionlint:1.7.9"
-      ],
+      command: "actionlint",
+      args: ["-color"],
       category: "workflow"
-    },
+    };
+  }
+  return {
+    name: "actionlint",
+    label: "Workflow Lint",
+    description: "GitHub Actions syntax validation",
+    command: "docker",
+    args: ["run", "--rm", "-v", `${process.cwd()}:/repo`, "-w", "/repo", "rhysd/actionlint:1.7.9"],
+    category: "workflow"
+  };
+}
+function getChecks(mode) {
+  return [
+    createActionlintCheck(mode),
     {
       name: "type-check",
       label: "Type Check",
@@ -2014,7 +2031,7 @@ function buildStepSummaryMarkdown2(summary) {
   return lines.join("\n");
 }
 function getChecksToRun(options) {
-  let checks = getChecks().filter((c) => {
+  let checks = getChecks(options.mode).filter((c) => {
     if (c.category === "workflow") return true;
     if (c.category === "core") return true;
     if (c.category === "build") return options.includeBuild;
@@ -2534,6 +2551,19 @@ function normalizeWhitespace(value) {
 function stableHash(payload) {
   return createHash("sha256").update(JSON.stringify(payload)).digest("hex").slice(0, 16);
 }
+function createCanonicalTableColumnPayload(row) {
+  return {
+    name: row.column_name,
+    type: normalizeWhitespace(row.data_type),
+    notNull: row.not_null,
+    default: normalizeWhitespace(row.default_expr),
+    identity: row.identity_kind ?? "",
+    generated: row.generated_kind ?? ""
+  };
+}
+function sortCanonicalTableColumns(columns) {
+  return [...columns].sort((left, right) => left.name.localeCompare(right.name));
+}
 function createCanonicalObject(kind, schema, name, label, payload, parentName) {
   return {
     kind,
@@ -2623,15 +2653,7 @@ function buildTableObjects(columns, flags, constraints) {
       rlsEnabled: false,
       rlsForced: false
     };
-    entry.columns.push({
-      attnum: row.attnum,
-      name: row.column_name,
-      type: normalizeWhitespace(row.data_type),
-      notNull: row.not_null,
-      default: normalizeWhitespace(row.default_expr),
-      identity: row.identity_kind ?? "",
-      generated: row.generated_kind ?? ""
-    });
+    entry.columns.push(createCanonicalTableColumnPayload(row));
     tables.set(key, entry);
   }
   for (const row of flags) {
@@ -2667,7 +2689,7 @@ function buildTableObjects(columns, flags, constraints) {
   }
   return Array.from(tables.values()).map(
     (table) => createCanonicalObject("table", table.schema, table.table, `${table.schema}.${table.table}`, {
-      columns: table.columns,
+      columns: sortCanonicalTableColumns(table.columns),
       constraints: table.constraints,
       rlsEnabled: table.rlsEnabled,
       rlsForced: table.rlsForced
@@ -3261,6 +3283,17 @@ function unavailableStats(error) {
     canonicalSnapshot: createUnavailableCanonicalSnapshot(error)
   };
 }
+function cloneEnvironmentStats(stats) {
+  return {
+    ...stats,
+    schemas: Object.fromEntries(
+      Object.entries(stats.schemas).map(([schema, values]) => [schema, { ...values }])
+    ),
+    total: { ...stats.total },
+    indexList: stats.indexList?.map((index) => ({ ...index })),
+    canonicalSnapshot: stats.canonicalSnapshot
+  };
+}
 function logSchemaStats(label, stats, includeSchemas = false) {
   const base = `[schema-stats] ${label}: ${stats.total.tables}T ${stats.total.functions}F ${stats.total.policies}P`;
   if (!includeSchemas) {
@@ -3368,20 +3401,60 @@ ${result.stderr || ""}`;
     dropReferenceDb(sourceDbUrl, referenceDb.dbName);
   }
 }
+async function resolveReferenceAndCiStats(params) {
+  const { repoRoot, tmpDir, referenceDbUrl, ciDbUrl, referenceStrategy } = params;
+  if (referenceStrategy === "reuse-ci" && ciDbUrl) {
+    console.log(
+      "[schema-stats] Reusing synced CI database as reference schema (skip temporary rebuild)"
+    );
+    const [ciResult2] = await Promise.allSettled([collectEnvironmentStats(ciDbUrl, "CI")]);
+    const ci = resolveSettledStats(ciResult2, "CI");
+    const reference = ci.available === false ? unavailableStats(ci.error ?? "CI database is unavailable for reference schema reuse") : cloneEnvironmentStats(ci);
+    return [reference, ci];
+  }
+  const [referenceResult, ciResult] = await Promise.allSettled([
+    buildReferenceStats(repoRoot, tmpDir, referenceDbUrl),
+    collectEnvironmentStats(ciDbUrl, "CI")
+  ]);
+  return [resolveSettledStats(referenceResult, "reference"), resolveSettledStats(ciResult, "CI")];
+}
 var collectSchemaStatsActor = fromPromise(
   async ({ input }) => {
-    const { repoRoot, referenceDbUrl, ciDbUrl, queryProduction, tmpDir } = input;
+    const {
+      repoRoot,
+      referenceDbUrl,
+      ciDbUrl,
+      referenceStrategy = "rebuild",
+      queryProduction,
+      tmpDir
+    } = input;
     console.log(
       "[schema-stats] Collecting schema statistics (Reference/CI/Production, parallel)..."
     );
     const productionUrl = process.env.GH_DATABASE_URL_ADMIN || process.env.GH_DATABASE_URL;
-    const [referenceResult, ciResult, productionResult] = await Promise.allSettled([
-      buildReferenceStats(repoRoot, tmpDir, referenceDbUrl),
-      collectEnvironmentStats(ciDbUrl, "CI"),
+    const [referenceResult, productionResult] = await Promise.allSettled([
+      resolveReferenceAndCiStats({
+        repoRoot,
+        tmpDir,
+        referenceDbUrl,
+        ciDbUrl,
+        referenceStrategy
+      }),
       collectEnvironmentStats(queryProduction ? productionUrl ?? null : null, "Production")
     ]);
-    const local = resolveSettledStats(referenceResult, "reference");
-    const ci = resolveSettledStats(ciResult, "CI");
+    let local;
+    let ci;
+    if (referenceResult.status === "fulfilled") {
+      local = referenceResult.value[0];
+      ci = referenceResult.value[1];
+    } else {
+      console.warn(
+        `[schema-stats] Failed to collect reference/CI schema statistics: ${referenceResult.reason}`
+      );
+      const reason = String(referenceResult.reason);
+      local = unavailableStats(reason);
+      ci = unavailableStats(reason);
+    }
     const production = resolveSettledProductionStats(productionResult);
     return {
       schemaStats: {
@@ -3713,24 +3786,27 @@ function extractHazardsWithContext(fullOutput, repoRoot) {
   appendEmojiHazards(fullOutput, idempotentRoles, hazards);
   return hazards;
 }
-function detectNoChanges(fullOutput) {
+function detectSchemaChangeState(fullOutput) {
   const lowerOutput = fullOutput.toLowerCase();
+  const changesIndicators = [
+    "check mode: schema changes detected (not applied)",
+    "schema changes: detected"
+  ];
+  if (changesIndicators.some((indicator) => lowerOutput.includes(indicator))) {
+    return "changes";
+  }
   const noChangesIndicators = [
+    "check mode: all changes are for idempotent-managed objects (nothing to apply)",
+    "schema changes: none",
     "no schema changes detected",
-    // From actors.ts line 969
-    "no schema changes",
-    // Shorter variant
     "already in sync",
-    "nothing to apply",
     "schemas are up to date",
-    "no changes were applied",
-    // From db-apply.ts line 150
-    "no changes",
-    // From actors.ts line 578, 968
-    "in sync"
-    // From db-sync.ts line 80
+    "nothing to apply"
   ];
-  return noChangesIndicators.some((indicator) => lowerOutput.includes(indicator));
+  if (noChangesIndicators.some((indicator) => lowerOutput.includes(indicator))) {
+    return "no-changes";
+  }
+  return "unknown";
 }
 function isCommandSuccess(exitCode, fullOutput) {
   return exitCode === 0 || fullOutput.includes("check complete") || fullOutput.includes("Check Summary");
@@ -3786,6 +3862,39 @@ function buildErrorResult(error, databaseUrl) {
     }
   };
 }
+function buildPreviewFromOutput(fullOutput, repoRoot, productionUrl) {
+  const lines = fullOutput.split("\n");
+  const planSql = extractSqlFromLines(lines) || extractSqlFromSchemaChanges(fullOutput);
+  const hazardDetails = extractHazardsWithContext(fullOutput, repoRoot);
+  const hazards = hazardDetails.map((h) => `${h.type}: ${h.message}`);
+  const schemaChangeState = detectSchemaChangeState(fullOutput);
+  const hasSqlPlan = planSql !== null && planSql.trim().length > 0;
+  const hasHazards = hazards.length > 0;
+  const hasChanges = schemaChangeState === "changes" ? true : schemaChangeState === "no-changes" ? false : hasSqlPlan || hasHazards;
+  const effectivePlanSql = hasChanges ? planSql?.substring(0, 5e3) || null : null;
+  const rawError = extractErrorMessage(fullOutput);
+  return {
+    planSql: effectivePlanSql,
+    hazards,
+    hazardDetails: hazardDetails.length > 0 ? hazardDetails : void 0,
+    hasChanges,
+    error: enhanceConnectionError(rawError, productionUrl)
+  };
+}
+function buildSuccessPreviewResult(exitCode, fullOutput, repoRoot, productionUrl) {
+  const isSuccess = isCommandSuccess(exitCode, fullOutput);
+  const preview = buildPreviewFromOutput(fullOutput, repoRoot, productionUrl);
+  return {
+    preview: {
+      executed: true,
+      planSql: preview.planSql,
+      hazards: preview.hazards,
+      hazardDetails: preview.hazardDetails,
+      hasChanges: preview.hasChanges,
+      error: isSuccess ? null : preview.error
+    }
+  };
+}
 var productionPreviewActor = fromPromise(
   async ({ input }) => {
     const { repoRoot, tmpDir, shouldExecute } = input;
@@ -3810,28 +3919,7 @@ var productionPreviewActor = fromPromise(
       const fullOutput = `${stdout}
 ${stderr}`;
       await writeLogFile(logFile, fullOutput);
-      const lines = fullOutput.split("\n");
-      const planSql = extractSqlFromLines(lines) || extractSqlFromSchemaChanges(fullOutput);
-      const hazardDetails = extractHazardsWithContext(fullOutput, repoRoot);
-      const hazards = hazardDetails.map((h) => `${h.type}: ${h.message}`);
-      const hasNoChangesIndicator = detectNoChanges(fullOutput);
-      const hasSqlPlan = planSql !== null && planSql.trim().length > 0;
-      const hasHazards = hazards.length > 0;
-      const hasChanges = hasNoChangesIndicator ? false : hasSqlPlan || hasHazards;
-      const effectivePlanSql = hasChanges ? planSql?.substring(0, 5e3) || null : null;
-      const isSuccess = isCommandSuccess(result.exitCode, fullOutput);
-      const rawError = !isSuccess ? extractErrorMessage(fullOutput) : null;
-      const errorMessage = rawError ? enhanceConnectionError(rawError, productionUrl) : null;
-      return {
-        preview: {
-          executed: true,
-          planSql: effectivePlanSql,
-          hazards,
-          hazardDetails: hazardDetails.length > 0 ? hazardDetails : void 0,
-          hasChanges,
-          error: errorMessage
-        }
-      };
+      return buildSuccessPreviewResult(result.exitCode, fullOutput, repoRoot, productionUrl);
     } catch (error) {
       return buildErrorResult(error, productionUrl);
     }
@@ -5783,6 +5871,9 @@ function getLayersForCorePhase(selectedLayers, mode) {
 function hasE2ELayer(selectedLayers) {
   return selectedLayers.includes(E2E_LAYER);
 }
+function shouldReuseCiReferenceStats(context) {
+  return context.mode !== "ci-local" && context.schemaApplied && context.schemaDrift !== null && context.schemaDrift?.hasDrift === false;
+}
 function mergeLayerResults(coreResults, e2eResults) {
   return { ...coreResults, ...e2eResults };
 }
@@ -5879,7 +5970,7 @@ init_esm_shims();
 var CI_STEPS = [
   { step: "setup", label: "\u74B0\u5883\u30BB\u30C3\u30C8\u30A2\u30C3\u30D7", detail: "\u30EA\u30DD\u30B8\u30C8\u30EA\u691C\u51FA\u3001Supabase\u8D77\u52D5" },
   { step: "syncSchema", label: "\u30B9\u30AD\u30FC\u30DE\u540C\u671F", detail: "pg-schema-diff \u2192 CI DB" },
-  { step: "applySeeds", label: "\u30B7\u30FC\u30C9\u9069\u7528", detail: "ci.sql + pgTAP + roles" },
+  { step: "applySeeds", label: "\u30B7\u30FC\u30C9\u9069\u7528", detail: "ci.sql + prerequisite seeds" },
   { step: "staticChecks", label: "\u9759\u7684\u30C1\u30A7\u30C3\u30AF", detail: "\u578B\u30C1\u30A7\u30C3\u30AF \u2225 lint" },
   { step: "build", label: "\u30D3\u30EB\u30C9", detail: "build \u2225 playwright install" },
   { step: "runTests", label: "\u30C6\u30B9\u30C8\u5B9F\u884C", detail: "L0-L3 (\u30D6\u30ED\u30C3\u30AD\u30F3\u30B0) \u2192 L4 (E2E)" },
@@ -6043,11 +6134,123 @@ function formatSkippedLayers(layerSkipReasons, originalSelectedLayers) {
   return lines;
 }
 
-// src/commands/ci/machine/formatters/sections/schema-matrix.ts
+// src/commands/ci/machine/formatters/sections/production-schema-status.ts
 init_esm_shims();
+var COUNT_FIELDS = [
+  "tables",
+  "functions",
+  "policies",
+  "indexes",
+  "triggers"
+];
 function emptyStats2() {
   return { tables: 0, functions: 0, policies: 0, indexes: 0, triggers: 0 };
 }
+function findExpectedCountDrift(schemaName, field, expectedDrift) {
+  return expectedDrift.find(
+    (entry) => entry.field === field && (entry.schemas === void 0 || entry.schemas.includes(schemaName))
+  ) ?? null;
+}
+function buildCountDiffs(schemaStats, expectedDrift) {
+  if (!schemaStats?.local || !schemaStats.production) return [];
+  if (schemaStats.local.available === false || schemaStats.production.available === false) {
+    return [];
+  }
+  const schemaNames = /* @__PURE__ */ new Set([
+    ...Object.keys(schemaStats.local.schemas),
+    ...Object.keys(schemaStats.production.schemas)
+  ]);
+  const diffs = [];
+  for (const schemaName of Array.from(schemaNames).sort()) {
+    const reference = schemaStats.local.schemas[schemaName] ?? emptyStats2();
+    const production = schemaStats.production.schemas[schemaName] ?? emptyStats2();
+    for (const field of COUNT_FIELDS) {
+      if (reference[field] === production[field]) continue;
+      const expected = findExpectedCountDrift(schemaName, field, expectedDrift);
+      diffs.push({
+        schema: schemaName,
+        field,
+        value: production[field],
+        reference: reference[field],
+        delta: production[field] - reference[field],
+        expected: expected !== null,
+        reason: expected?.reason
+      });
+    }
+  }
+  return diffs;
+}
+function areIndexDiffsCoveredByExpectedDrift(indexDiff, countDiffs) {
+  if (!indexDiff || !hasIndexDiff(indexDiff)) return false;
+  const touchedSchemas = /* @__PURE__ */ new Set([
+    ...indexDiff.missing.map((index) => index.schema),
+    ...indexDiff.extra.map((index) => index.schema)
+  ]);
+  if (touchedSchemas.size === 0) return false;
+  const expectedIndexSchemas = new Set(
+    countDiffs.filter((diff) => diff.field === "indexes" && diff.expected).map((diff) => diff.schema)
+  );
+  const unexpectedIndexSchemas = new Set(
+    countDiffs.filter((diff) => diff.field === "indexes" && !diff.expected).map((diff) => diff.schema)
+  );
+  for (const schema of touchedSchemas) {
+    if (unexpectedIndexSchemas.has(schema)) return false;
+    if (!expectedIndexSchemas.has(schema)) return false;
+  }
+  return true;
+}
+function buildIndexDiff(schemaStats) {
+  if (!schemaStats?.local || !schemaStats.production) return null;
+  if (schemaStats.local.available === false || schemaStats.production.available === false) {
+    return null;
+  }
+  return compareIndexLists(schemaStats.local, schemaStats.production);
+}
+function buildSemanticDiff(schemaStats) {
+  const referenceSnapshot = schemaStats?.local?.canonicalSnapshot;
+  const productionSnapshot = schemaStats?.production?.canonicalSnapshot;
+  if (!referenceSnapshot || !productionSnapshot) return null;
+  if (referenceSnapshot.available !== true || productionSnapshot.available !== true) return null;
+  return compareCanonicalSnapshots(referenceSnapshot, productionSnapshot);
+}
+function getProductionSchemaSignals(productionPreview, schemaStats, expectedDrift = []) {
+  const previewHasChanges = productionPreview?.hasChanges === true;
+  const indexDiff = buildIndexDiff(schemaStats);
+  const semanticDiff = buildSemanticDiff(schemaStats);
+  const countDiffs = buildCountDiffs(schemaStats, expectedDrift);
+  const hasIndexChanges = indexDiff ? hasIndexDiff(indexDiff) : false;
+  const hasUnexpectedIndexChanges = hasIndexChanges && !areIndexDiffsCoveredByExpectedDrift(indexDiff, countDiffs);
+  const hasSemanticChanges = semanticDiff ? hasCanonicalChanges(semanticDiff) : false;
+  const hasCountChanges = countDiffs.length > 0;
+  const hasUnexpectedCountChanges = countDiffs.some((diff) => !diff.expected);
+  const knownDriftReasons = Array.from(
+    new Set(countDiffs.filter((diff) => diff.expected).flatMap((diff) => diff.reason ?? []))
+  );
+  const hasKnownDriftOnly = hasCountChanges && !previewHasChanges && !hasUnexpectedCountChanges && !hasUnexpectedIndexChanges && !hasSemanticChanges;
+  const requiresDeploy = previewHasChanges || hasUnexpectedIndexChanges || hasSemanticChanges || hasUnexpectedCountChanges;
+  return {
+    previewHasChanges,
+    indexDiff,
+    semanticDiff,
+    countDiffs,
+    hasIndexChanges,
+    hasUnexpectedIndexChanges,
+    hasSemanticChanges,
+    hasCountChanges,
+    hasUnexpectedCountChanges,
+    hasKnownDriftOnly,
+    knownDriftReasons,
+    requiresDeploy,
+    previewMissedChanges: !previewHasChanges && (hasUnexpectedIndexChanges || hasSemanticChanges || hasUnexpectedCountChanges),
+    previewOnlyChanges: previewHasChanges && !hasUnexpectedIndexChanges && !hasSemanticChanges && !hasUnexpectedCountChanges
+  };
+}
+
+// src/commands/ci/machine/formatters/sections/schema-matrix.ts
+init_esm_shims();
+function emptyStats3() {
+  return { tables: 0, functions: 0, policies: 0, indexes: 0, triggers: 0 };
+}
 function isStatsAvailable(stats) {
   return stats != null && stats.available !== false;
 }
@@ -6127,8 +6330,8 @@ function getSortedActiveSchemas(schemaStats) {
 function generateSchemaTableRows(schemaStats, sortedSchemas, hasProduction, expectedDrift, ciDiffBySchema, productionDiffBySchema) {
   const lines = [];
   for (const schemaName of sortedSchemas) {
-    const localStats = schemaStats.local.schemas[schemaName] ?? emptyStats2();
-    const ciStats = schemaStats.ci.schemas[schemaName] ?? emptyStats2();
+    const localStats = schemaStats.local.schemas[schemaName] ?? emptyStats3();
+    const ciStats = schemaStats.ci.schemas[schemaName] ?? emptyStats3();
     const prodStats = schemaStats.production?.schemas[schemaName] ?? null;
     const localCell = formatReferenceCell(localStats, isStatsAvailable(schemaStats.local));
     const ciCell = formatCiCellWithDiff(
@@ -6285,7 +6488,7 @@ function generateExpectedDriftFootnotes(schemaStats, sortedSchemas, expectedDrif
   if (!isStatsAvailable(schemaStats.local) || !isStatsAvailable(schemaStats.production)) return [];
   const allReasons = /* @__PURE__ */ new Set();
   for (const schemaName of sortedSchemas) {
-    const localStats = schemaStats.local.schemas[schemaName] ?? emptyStats2();
+    const localStats = schemaStats.local.schemas[schemaName] ?? emptyStats3();
     const prodStats = schemaStats.production.schemas[schemaName];
     if (!prodStats || !hasDisplayedStatsDiff(prodStats, localStats)) continue;
     const fieldDiffs = getFieldDiffs(prodStats, localStats);
@@ -6507,23 +6710,6 @@ function classifyPreviewError(error) {
   }
   return { label: "\u672C\u756A\u30D7\u30EC\u30D3\u30E5\u30FC\u5931\u6557", guidance: "" };
 }
-function generateIndexDiffWarning(schemaStats) {
-  if (!schemaStats?.local || !schemaStats?.production) return [];
-  if (schemaStats.local.available === false || schemaStats.production.available === false)
-    return [];
-  const indexDiff = compareIndexLists(schemaStats.local, schemaStats.production);
-  if (!hasIndexDiff(indexDiff)) return [];
-  const diffParts = [];
-  if (indexDiff.missing.length > 0) diffParts.push(`${indexDiff.missing.length}\u4EF6\u4E0D\u8DB3`);
-  if (indexDiff.extra.length > 0) diffParts.push(`${indexDiff.extra.length}\u4EF6\u4F59\u5206`);
-  return [
-    `> \u26A0\uFE0F **\u30A4\u30F3\u30C7\u30C3\u30AF\u30B9\u5DEE\u5206\u691C\u51FA** (${diffParts.join(", ")})`,
-    ">",
-    "> pg-schema-diff \u3067\u306F\u691C\u51FA\u3055\u308C\u307E\u305B\u3093\u3067\u3057\u305F\u304C\u3001\u30A4\u30F3\u30C7\u30C3\u30AF\u30B9\u306E\u5DEE\u5206\u304C\u3042\u308A\u307E\u3059\u3002",
-    "> \u30B9\u30AD\u30FC\u30DE\u30DE\u30C8\u30EA\u30C3\u30AF\u30B9\u306E\u8A73\u7D30\u3092\u78BA\u8A8D\u3057\u3066\u304F\u3060\u3055\u3044\u3002",
-    ""
-  ];
-}
 function generatePreviewError(error) {
   const { label, guidance } = classifyPreviewError(error);
   const lines = [`> \u26A0\uFE0F **${label}**`];
@@ -6544,7 +6730,82 @@ function generatePreviewError(error) {
   );
   return lines;
 }
-function generateProductionPreviewSection(prodPreview, schemaDrift, schemaStats) {
+function generatePreviewChangesDetectedSection(prodPreview, previewOnlyChanges) {
+  const lines = [
+    "> \u{1F536} **\u30B9\u30AD\u30FC\u30DE\u5909\u66F4\u691C\u51FA - \u672C\u756A\u30C7\u30D7\u30ED\u30A4\u304C\u5FC5\u8981\u3067\u3059**",
+    ">",
+    "> \u3053\u306EPR\u3092\u30DE\u30FC\u30B8\u3057\u305F\u5F8C\u3001\u672C\u756A\u30C7\u30D7\u30ED\u30A4\u30EF\u30FC\u30AF\u30D5\u30ED\u30FC\u3092\u5B9F\u884C\u3057\u3066\u30B9\u30AD\u30FC\u30DE\u5909\u66F4\u3092\u9069\u7528\u3057\u3066\u304F\u3060\u3055\u3044\u3002",
+    ""
+  ];
+  if (previewOnlyChanges) {
+    lines.push(
+      "> \u88DC\u8DB3: `Prod semantic diff` / count diff / index diff \u3067\u306F\u5DEE\u5206\u304C\u306A\u304F\u3001`production --check` \u306E\u307F\u304C\u5909\u66F4\u3092\u691C\u51FA\u3057\u307E\u3057\u305F\u3002",
+      "> \u3053\u308C\u306F grants / ACL / ownership \u306A\u3069 canonical semantic diff \u306E\u5BFE\u8C61\u5916\u5DEE\u5206\u3067\u3042\u308B\u53EF\u80FD\u6027\u304C\u3042\u308A\u307E\u3059\u3002",
+      ""
+    );
+  }
+  if (prodPreview.planSql) {
+    lines.push(...generatePreviewDetails(prodPreview));
+  }
+  return lines;
+}
+function buildComparisonMismatchReasons(schemaStats, expectedDrift) {
+  const signals = getProductionSchemaSignals(null, schemaStats, expectedDrift);
+  const reasons = [];
+  if (signals.hasSemanticChanges && signals.semanticDiff) {
+    const diff = signals.semanticDiff;
+    reasons.push(
+      `semantic diff: changed ${diff.changed.length}, missing ${diff.missing.length}, extra ${diff.extra.length}, renamed ${diff.renamed.length}`
+    );
+  }
+  if (signals.hasIndexChanges && signals.indexDiff) {
+    reasons.push(
+      `index diff: missing ${signals.indexDiff.missing.length}, extra ${signals.indexDiff.extra.length}`
+    );
+  }
+  if (signals.hasUnexpectedCountChanges) {
+    const unexpectedDiffs = signals.countDiffs.filter((diff) => !diff.expected);
+    const formatted = unexpectedDiffs.slice(0, 6).map(
+      (diff) => `${diff.schema}.${diff.field} ${diff.reference} -> ${diff.value} (${diff.delta >= 0 ? "+" : ""}${diff.delta})`
+    );
+    reasons.push(`count diff: ${formatted.join(", ")}${unexpectedDiffs.length > 6 ? ", ..." : ""}`);
+  }
+  return reasons;
+}
+function generateComparisonMismatchSection(schemaStats, expectedDrift) {
+  const reasons = buildComparisonMismatchReasons(schemaStats, expectedDrift);
+  const lines = [
+    "> \u{1F536} **\u672C\u756ADB\u3068\u306E\u5DEE\u5206\u691C\u51FA - \u672C\u756A\u30C7\u30D7\u30ED\u30A4\u304C\u5FC5\u8981\u3067\u3059**",
+    ">",
+    "> `runa db apply production --check` \u306F\u5909\u66F4\u306A\u3057\u5224\u5B9A\u3067\u3057\u305F\u304C\u3001Reference \u2194 Prod \u306E\u6BD4\u8F03\u3067\u5DEE\u5206\u3092\u691C\u51FA\u3057\u307E\u3057\u305F\u3002",
+    "> \u30B9\u30AD\u30FC\u30DE\u30DE\u30C8\u30EA\u30C3\u30AF\u30B9\u306E `Prod semantic diff` \u3068\u8A73\u7D30\u30ED\u30B0\u3092\u78BA\u8A8D\u3057\u3066\u304F\u3060\u3055\u3044\u3002",
+    ""
+  ];
+  for (const reason of reasons) {
+    lines.push(`> - ${reason}`);
+  }
+  if (reasons.length > 0) {
+    lines.push("");
+  }
+  return lines;
+}
+function generateKnownDriftOnlySection(schemaStats, expectedDrift) {
+  const signals = getProductionSchemaSignals(null, schemaStats, expectedDrift);
+  const lines = [
+    "**\u672C\u756A\u30D7\u30EC\u30D3\u30E5\u30FC**: \u2705 \u672C\u756A\u30C7\u30D7\u30ED\u30A4\u304C\u5FC5\u8981\u306A\u30B9\u30AD\u30FC\u30DE\u5909\u66F4\u306F\u3042\u308A\u307E\u305B\u3093",
+    "",
+    "> \u{1F4CB} **\u65E2\u77E5\u306E\u5DEE\u5206\u306E\u307F\u691C\u51FA**",
+    ">",
+    "> Reference \u2194 Prod \u306B\u306F `expectedDrift` \u3067\u8A31\u5BB9\u6E08\u307F\u306E\u5DEE\u5206\u306E\u307F\u304C\u3042\u308A\u307E\u3059\u3002\u8FFD\u52A0\u306E db apply/deploy \u306F\u4E0D\u8981\u3067\u3059\u3002"
+  ];
+  for (const reason of signals.knownDriftReasons) {
+    lines.push(`> - ${reason}`);
+  }
+  lines.push("");
+  return lines;
+}
+function generateProductionPreviewSection(prodPreview, schemaDrift, schemaStats, expectedDrift) {
+  const signals = getProductionSchemaSignals(prodPreview, schemaStats, expectedDrift);
   if (!prodPreview?.executed) {
     if (schemaDrift?.gitDiff?.filesChanged?.length) {
       return [
@@ -6557,20 +6818,15 @@ function generateProductionPreviewSection(prodPreview, schemaDrift, schemaStats)
     return [];
   }
   if (prodPreview.error) return generatePreviewError(prodPreview.error);
-  if (prodPreview.hasChanges) {
-    const lines = [
-      "> \u{1F536} **\u30B9\u30AD\u30FC\u30DE\u5909\u66F4\u691C\u51FA - \u672C\u756A\u30C7\u30D7\u30ED\u30A4\u304C\u5FC5\u8981\u3067\u3059**",
-      ">",
-      "> \u3053\u306EPR\u3092\u30DE\u30FC\u30B8\u3057\u305F\u5F8C\u3001\u672C\u756A\u30C7\u30D7\u30ED\u30A4\u30EF\u30FC\u30AF\u30D5\u30ED\u30FC\u3092\u5B9F\u884C\u3057\u3066\u30B9\u30AD\u30FC\u30DE\u5909\u66F4\u3092\u9069\u7528\u3057\u3066\u304F\u3060\u3055\u3044\u3002",
-      ""
-    ];
-    if (prodPreview.planSql) {
-      lines.push(...generatePreviewDetails(prodPreview));
-    }
-    return lines;
+  if (signals.previewHasChanges) {
+    return generatePreviewChangesDetectedSection(prodPreview, signals.previewOnlyChanges);
+  }
+  if (signals.previewMissedChanges) {
+    return generateComparisonMismatchSection(schemaStats, expectedDrift);
+  }
+  if (signals.hasKnownDriftOnly) {
+    return generateKnownDriftOnlySection(schemaStats, expectedDrift);
   }
-  const indexWarning = generateIndexDiffWarning(schemaStats);
-  if (indexWarning.length > 0) return indexWarning;
   return ["**\u672C\u756A\u30D7\u30EC\u30D3\u30E5\u30FC**: \u2705 \u672C\u756A\u306B\u9069\u7528\u3059\u308B\u30B9\u30AD\u30FC\u30DE\u5909\u66F4\u306F\u3042\u308A\u307E\u305B\u3093", ""];
 }
 function shouldShowDeployButton(productionPreview, schemaDrift, hasSchemaChanges2) {
@@ -6579,18 +6835,19 @@ function shouldShowDeployButton(productionPreview, schemaDrift, hasSchemaChanges
   if (!productionPreview?.executed && schemaDrift?.gitDiff?.filesChanged?.length) return true;
   return false;
 }
-function generateDeploySection(exitCode, layerResults, gitBranchName, productionPreview, schemaDrift, schemaStats, env) {
+function generateDeploySection(exitCode, layerResults, gitBranchName, productionPreview, schemaDrift, schemaStats, expectedDrift, env) {
   if (!checkIfDeployable(exitCode, layerResults)) return [];
   const deployWorkflowUrl = env.repository ? `${env.serverUrl}/${env.repository}/actions/workflows/deploy-db.yml` : null;
-  const hasPgSchemaDiffChanges = productionPreview?.hasChanges === true;
-  const hasIndexChanges = schemaStats?.local && schemaStats?.production ? hasIndexDiff(compareIndexLists(schemaStats.local, schemaStats.production)) : false;
-  const hasSchemaChanges2 = hasPgSchemaDiffChanges || hasIndexChanges;
+  const signals = getProductionSchemaSignals(productionPreview, schemaStats, expectedDrift);
+  const hasSchemaChanges2 = signals.requiresDeploy;
   const headerEmoji = hasSchemaChanges2 ? "\u{1F6A8}" : "\u{1F680}";
   const headerText = hasSchemaChanges2 ? "\u672C\u756A\u30C7\u30D7\u30ED\u30A4 (\u30B9\u30AD\u30FC\u30DE\u5909\u66F4\u3042\u308A!)" : "\u672C\u756A\u30C7\u30D7\u30ED\u30A4";
   const lines = ["---", "", `### ${headerEmoji} ${headerText}`, ""];
   if (exitCode !== 0)
     lines.push("> **\u6CE8**: Layer 4 (E2E) \u306F\u5931\u6557\u3057\u307E\u3057\u305F\u304C\u3001\u30B9\u30AD\u30FC\u30DE\u5909\u66F4\u306F\u30C7\u30D7\u30ED\u30A4\u53EF\u80FD\u3067\u3059\u3002", "");
-  lines.push(...generateProductionPreviewSection(productionPreview, schemaDrift, schemaStats));
+  lines.push(
+    ...generateProductionPreviewSection(productionPreview, schemaDrift, schemaStats, expectedDrift)
+  );
   const showButton = shouldShowDeployButton(productionPreview, schemaDrift, hasSchemaChanges2);
   if (deployWorkflowUrl && showButton) {
     const buttonText = hasSchemaChanges2 ? "\u26A1 \u30B9\u30AD\u30FC\u30DE\u5909\u66F4\u3092\u672C\u756A\u306B\u30C7\u30D7\u30ED\u30A4" : "\u25B6\uFE0F \u672C\u756A\u306B\u30C7\u30D7\u30ED\u30A4";
@@ -6630,6 +6887,7 @@ function generateIntermediateCommentBody(input) {
       productionPreview,
       schemaDrift,
       input.schemaStats ?? null,
+      input.expectedDrift ?? [],
       env
     ),
     "<sub>\u{1F916} RUNA CI \u751F\u6210 (\u4E2D\u9593\u66F4\u65B0)</sub>"
@@ -6665,6 +6923,7 @@ function generateCommentBody(input) {
       input.productionPreview,
       schemaDrift,
       input.schemaStats ?? null,
+      input.expectedDrift ?? [],
       env
     ),
     "<sub>\u{1F916} RUNA CI \u751F\u6210</sub>"
@@ -6714,7 +6973,7 @@ function formatSyncSchemaDetail(schemaDrift) {
   if (!hasGitChanges) {
     const hasSqlContent = schemaDrift.beforeSql && schemaDrift.beforeSql.trim().length > 0;
     if (hasSqlContent) {
-      return "ci.sql + pgTAP + roles";
+      return "ci.sql + prerequisite seeds";
     }
     return "SQL\u30D5\u30A1\u30A4\u30EB\u5909\u66F4\u306A\u3057";
   }
@@ -6754,7 +7013,7 @@ function formatRunTestsDetail(layerResults) {
 }
 var stepDetailHandlers = {
   syncSchema: (_status, schemaDrift) => formatSyncSchemaDetail(schemaDrift),
-  applySeeds: () => "ci.sql + pgTAP + roles",
+  applySeeds: () => "ci.sql + prerequisite seeds",
   staticChecks: (status) => status === "passed" ? "\u578B\u30C1\u30A7\u30C3\u30AF \u2713 lint \u2713" : "\u578B\u30C1\u30A7\u30C3\u30AF \u2717 \u307E\u305F\u306F lint \u2717",
   build: (status) => status === "passed" ? "\u30A2\u30D7\u30EA\u30D3\u30EB\u30C9\u5B8C\u4E86, Playwright\u6E96\u5099\u5B8C\u4E86" : "\u30D3\u30EB\u30C9\u5931\u6557",
   runTests: (_status, _schemaDrift, layerResults) => formatRunTestsDetail(layerResults)
@@ -7182,7 +7441,7 @@ function createInitialContext(input) {
 function createOutput(context) {
   return {
     mode: context.mode,
-    status: context.error ? "failure" : "success",
+    status: context.exitCode === 0 && !context.error ? "success" : "failure",
     repoKind: context.repoKind,
     steps: {},
     // Populated from summary
@@ -7751,10 +8010,17 @@ var ciMachine = setup({
           databaseUrl: context.supabase?.databaseUrlRaw ?? "",
           mode: context.mode
         }),
-        onDone: {
-          actions: assign({ seedsApplied: ({ event }) => event.output.applied }),
-          target: "productionPreview"
-        },
+        onDone: [
+          {
+            guard: "isCiLocalMode",
+            actions: assign({ seedsApplied: ({ event }) => event.output.applied }),
+            target: "productionPreview"
+          },
+          {
+            actions: assign({ seedsApplied: ({ event }) => event.output.applied }),
+            target: "postSeedPr"
+          }
+        ],
         onError: {
           // Seeds failure is CRITICAL - blocks CI (Layer 2/3 tests depend on seeds)
           target: "failed",
@@ -7766,6 +8032,371 @@ var ciMachine = setup({
       }
     },
     // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+    // Post-Seed PR Phase
+    // CI PR path only: run observability work in parallel with the critical build/test path
+    // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+    postSeedPr: {
+      type: "parallel",
+      meta: {
+        e2e: {
+          observable: "log",
+          assertions: [{ type: "log", contains: "Database roles configured" }]
+        }
+      },
+      states: {
+        execution: {
+          initial: "setupRoles",
+          states: {
+            setupRoles: {
+              invoke: {
+                src: "setupRoles",
+                input: ({ context }) => createSetupRolesInput(context),
+                onDone: {
+                  target: "staticChecks",
+                  actions: assign({
+                    rolesSetup: true,
+                    supabase: ({ context, event }) => mergeSetupRolesSupabase(context, event.output.appDatabaseUrl)
+                  })
+                },
+                onError: {
+                  target: "staticChecks",
+                  actions: assign({ rolesSetup: false })
+                }
+              }
+            },
+            staticChecks: {
+              always: [{ guard: "shouldSkipStaticChecks", target: "buildAndPlaywright" }],
+              invoke: {
+                src: "staticChecks",
+                input: ({ context }) => createStaticChecksInput(context),
+                onDone: [
+                  {
+                    guard: ({ event }) => !event.output.passed,
+                    target: "failed",
+                    actions: assign({
+                      staticChecksPassed: false,
+                      error: ({ event }) => event.output.error ?? "Static checks failed"
+                    })
+                  },
+                  {
+                    target: "buildAndPlaywright",
+                    actions: assign({ staticChecksPassed: true })
+                  }
+                ],
+                onError: {
+                  target: "failed",
+                  actions: assign({
+                    staticChecksPassed: false,
+                    error: ({ event }) => extractErrorMessage2(event, "Static checks failed")
+                  })
+                }
+              }
+            },
+            buildAndPlaywright: {
+              always: [{ guard: "shouldSkipBuild", target: "appStart" }],
+              invoke: {
+                src: "buildAndPlaywright",
+                input: ({ context }) => ({
+                  ...createBuildAndPlaywrightInput(context),
+                  skipPlaywright: shouldSkipPlaywrightInstall(context)
+                }),
+                onDone: [
+                  {
+                    guard: ({ event }) => !event.output.buildPassed,
+                    target: "failed",
+                    actions: assign({
+                      appBuildPassed: false,
+                      playwrightInstalled: ({ event }) => event.output.playwrightInstalled,
+                      manifestGenerated: ({ event }) => event.output.manifestGenerated,
+                      error: ({ event }) => event.output.buildError ?? "App build failed"
+                    })
+                  },
+                  {
+                    target: "appStart",
+                    actions: assign({
+                      appBuildPassed: true,
+                      playwrightInstalled: ({ event }) => event.output.playwrightInstalled,
+                      manifestGenerated: ({ event }) => event.output.manifestGenerated
+                    })
+                  }
+                ],
+                onError: {
+                  target: "failed",
+                  actions: assign({
+                    appBuildPassed: false,
+                    error: ({ event }) => extractErrorMessage2(event, "App build failed")
+                  })
+                }
+              }
+            },
+            appStart: {
+              always: [{ guard: "shouldSkipAppStart", target: "capabilities" }],
+              invoke: {
+                src: "appStart",
+                input: ({ context }) => createAppStartInput(context),
+                onDone: [
+                  {
+                    guard: ({ event }) => !event.output.started,
+                    target: "failed",
+                    actions: assign({
+                      appStarted: false,
+                      error: ({ event }) => event.output.error ?? "App start failed"
+                    })
+                  },
+                  {
+                    target: "capabilities",
+                    actions: assign({
+                      appStarted: true,
+                      appPid: ({ event }) => event.output.pid ?? null,
+                      baseUrl: ({ event }) => event.output.baseUrl ?? null
+                    })
+                  }
+                ],
+                onError: {
+                  target: "failed",
+                  actions: assign({
+                    appStarted: false,
+                    error: ({ event }) => extractErrorMessage2(event, "App start failed")
+                  })
+                }
+              }
+            },
+            capabilities: {
+              invoke: {
+                src: "capabilities",
+                input: ({ context }) => createCapabilitiesInput(context),
+                onDone: {
+                  target: "runCoreTests",
+                  actions: assign({
+                    capabilities: ({ event }) => event.output.detected?.capabilities ?? [],
+                    selectedLayers: ({ context, event }) => filterRunnableLayers(context.selectedLayers, event.output.layerContent),
+                    layerSkipReasons: ({ event }) => extractLayerSkipReasons(event.output.layerContent)
+                  })
+                },
+                onError: {
+                  target: "runCoreTests"
+                }
+              }
+            },
+            runCoreTests: {
+              invoke: {
+                src: "runLayers",
+                input: ({ context }) => createRunCoreTestsInput(context),
+                onDone: [
+                  {
+                    guard: ({ event }) => {
+                      const failedLayers = event.output.failedLayers ?? [];
+                      return failedLayers.length > 0;
+                    },
+                    target: "coreTestsFailed",
+                    actions: assign({
+                      testsRun: true,
+                      layerResults: ({ event }) => deriveCoreLayerResults(event.output)
+                    })
+                  },
+                  {
+                    target: "coreTestsComplete",
+                    actions: assign({
+                      testsRun: true,
+                      layerResults: ({ context, event }) => {
+                        const nextResults = convertLayerResults(event.output.results);
+                        return mergeLayerResults(context.layerResults, nextResults);
+                      }
+                    })
+                  }
+                ],
+                onError: {
+                  target: "coreTestsFailed",
+                  actions: assign({
+                    testsRun: true,
+                    error: ({ event }) => extractErrorMessage2(event, "Core tests failed")
+                  })
+                }
+              }
+            },
+            coreTestsComplete: {
+              always: [
+                { guard: ({ context }) => hasE2ELayer(context.selectedLayers), target: "e2ePhase" },
+                {
+                  target: "done",
+                  actions: assign({
+                    exitCode: ({ context }) => computeExitCodeFromLayerResults(context.layerResults)
+                  })
+                }
+              ]
+            },
+            coreTestsFailed: {
+              entry: assign({
+                exitCode: ({ context }) => {
+                  if (Object.keys(context.layerResults).length === 0) {
+                    return 1;
+                  }
+                  return computeExitCodeFromLayerResults(context.layerResults);
+                }
+              }),
+              always: [{ target: "#ci.finalize" }]
+            },
+            e2ePhase: {
+              type: "parallel",
+              states: {
+                intermediateComment: {
+                  initial: "checking",
+                  states: {
+                    checking: {
+                      always: [
+                        {
+                          guard: ({ context }) => !context.prContext?.prNumber,
+                          target: "done"
+                        },
+                        {
+                          guard: ({ context }) => !shouldPostGitHubComment(context),
+                          target: "done"
+                        },
+                        { target: "posting" }
+                      ]
+                    },
+                    posting: {
+                      invoke: {
+                        src: "upsertComment",
+                        input: ({ context }) => createIntermediateCommentRequest(context),
+                        onDone: "done",
+                        onError: "done"
+                      }
+                    },
+                    done: { type: "final" }
+                  }
+                },
+                e2eTests: {
+                  initial: "running",
+                  states: {
+                    running: {
+                      invoke: {
+                        src: "runLayers",
+                        input: ({ context }) => createE2ERunLayersInput(context),
+                        onDone: {
+                          target: "done",
+                          actions: assign({
+                            layerResults: ({ context, event }) => {
+                              const e2eResults = convertLayerResults(event.output.results);
+                              return mergeLayerResults(context.layerResults, e2eResults);
+                            }
+                          })
+                        },
+                        onError: {
+                          target: "done",
+                          actions: assign({
+                            layerResults: ({ context }) => ({
+                              ...context.layerResults,
+                              [E2E_LAYER]: { status: "failed", exitCode: 1 }
+                            })
+                          })
+                        }
+                      }
+                    },
+                    done: { type: "final" }
+                  }
+                }
+              },
+              onDone: [
+                {
+                  guard: ({ context }) => Object.values(context.layerResults).some(
+                    (result) => result.status === "failed"
+                  ),
+                  target: "failed",
+                  actions: assign({
+                    exitCode: ({ context }) => computeExitCodeFromLayerResults(context.layerResults)
+                  })
+                },
+                {
+                  target: "done",
+                  actions: assign({
+                    exitCode: ({ context }) => computeExitCodeFromLayerResults(context.layerResults)
+                  })
+                }
+              ]
+            },
+            failed: {
+              always: [
+                {
+                  target: "#ci.finalize",
+                  actions: assign({
+                    exitCode: ({ context }) => context.exitCode !== 0 ? context.exitCode : 1
+                  })
+                }
+              ]
+            },
+            done: {
+              type: "final"
+            }
+          }
+        },
+        observability: {
+          initial: "productionPreview",
+          states: {
+            productionPreview: {
+              invoke: {
+                src: "productionPreview",
+                input: ({ context }) => ({
+                  repoRoot: assertRepoRoot(context),
+                  tmpDir: assertTmpDir(context),
+                  shouldExecute: Boolean(context.input.productionDatabaseUrl?.trim())
+                }),
+                onDone: {
+                  target: "collectSchemaStats",
+                  actions: assign({
+                    productionPreview: ({ event }) => event.output.preview
+                  })
+                },
+                onError: {
+                  target: "collectSchemaStats",
+                  actions: assign({
+                    productionPreview: ({ event }) => ({
+                      executed: true,
+                      planSql: null,
+                      hazards: [],
+                      hasChanges: false,
+                      error: event.error instanceof Error ? event.error.message : "Production preview failed"
+                    })
+                  })
+                }
+              }
+            },
+            collectSchemaStats: {
+              invoke: {
+                src: "collectSchemaStats",
+                input: ({ context }) => ({
+                  repoRoot: context.repoRoot ?? process.cwd(),
+                  referenceDbUrl: context.supabase?.databaseUrlRaw ?? null,
+                  ciDbUrl: context.supabase?.databaseUrlRaw ?? null,
+                  referenceStrategy: shouldReuseCiReferenceStats(context) ? "reuse-ci" : "rebuild",
+                  queryProduction: true,
+                  tmpDir: context.tmpDir ?? process.cwd()
+                }),
+                onDone: {
+                  target: "done",
+                  actions: assign({
+                    schemaStats: ({ event }) => event.output.schemaStats
+                  })
+                },
+                onError: {
+                  target: "done",
+                  actions: assign({
+                    schemaStats: () => null
+                  })
+                }
+              }
+            },
+            done: {
+              type: "final"
+            }
+          }
+        }
+      },
+      onDone: {
+        target: "finalize"
+      }
+    },
+    // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
     // Production Preview (ci-pr modes only, when schema changes exist)
     // Runs dry-run against production to show what SQL would be applied
     // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
@@ -7825,7 +8456,7 @@ var ciMachine = setup({
           repoRoot: context.repoRoot ?? process.cwd(),
           referenceDbUrl: context.supabase?.databaseUrlRaw ?? null,
           ciDbUrl: context.supabase?.databaseUrlRaw ?? null,
-          // Query production only in ci-pr modes
+          referenceStrategy: shouldReuseCiReferenceStats(context) ? "reuse-ci" : "rebuild",
           queryProduction: context.mode !== "ci-local",
           tmpDir: context.tmpDir ?? process.cwd()
         }),
@@ -8361,6 +8992,19 @@ var STATE_TO_STEP = {
   pullProduction: "syncSchema",
   syncSchema: "syncSchema",
   applySeeds: "applySeeds",
+  postSeedPr: "applySeeds",
+  "postSeedPr.execution.setupRoles": "applySeeds",
+  "postSeedPr.execution.staticChecks": "staticChecks",
+  "postSeedPr.execution.buildAndPlaywright": "build",
+  "postSeedPr.execution.appStart": "build",
+  "postSeedPr.execution.capabilities": "build",
+  "postSeedPr.execution.runCoreTests": "runTests",
+  "postSeedPr.execution.coreTestsComplete": "runTests",
+  "postSeedPr.execution.coreTestsFailed": "runTests",
+  "postSeedPr.execution.e2ePhase": "runTests",
+  "postSeedPr.execution.done": "runTests",
+  "postSeedPr.observability.productionPreview": "applySeeds",
+  "postSeedPr.observability.collectSchemaStats": "applySeeds",
   decidePath: "applySeeds",
   installPgTap: "applySeeds",
   setupRoles: "applySeeds",
@@ -8398,6 +9042,17 @@ var STEP_ORDER = [
   "runTests",
   "finalize"
 ];
+function resolveStepForState(state) {
+  let cursor = state;
+  while (cursor.length > 0) {
+    const step = STATE_TO_STEP[cursor];
+    if (step) return step;
+    const nextDot = cursor.lastIndexOf(".");
+    if (nextDot === -1) break;
+    cursor = cursor.slice(0, nextDot);
+  }
+  return void 0;
+}
 function getCompletedSteps(currentStep) {
   const currentIndex = STEP_ORDER.indexOf(currentStep);
   if (currentIndex <= 0) return [];
@@ -8486,8 +9141,8 @@ function determineFailedStep(context) {
 function handleProgressCommentUpdate(snapshot, prevState) {
   const currentState = getStateName(snapshot);
   const context = snapshot.context;
-  const currentStep = STATE_TO_STEP[currentState];
-  const prevStep = STATE_TO_STEP[prevState];
+  const currentStep = resolveStepForState(currentState);
+  const prevStep = resolveStepForState(prevState);
   if (!currentStep || currentStep === prevStep) return;
   recordStepTiming(currentStep);
   if (currentStep === "finalize") {
@@ -9054,6 +9709,75 @@ var stateLogHandlers2 = {
     logSection3("Database: Apply Seeds (db seed)");
     logger.info("Running: pnpm exec runa db seed ci --auto-approve");
   },
+  "postSeedPr.execution.setupRoles": (ctx, logger) => {
+    if (ctx.seedsApplied) {
+      logger.success("Seeds applied successfully");
+    }
+    logSection3("Database: Setup Roles (db:setup-roles)");
+    logger.info("Running: pnpm db:setup-roles");
+  },
+  "postSeedPr.observability.productionPreview": (ctx, logger) => {
+    if (ctx.seedsApplied) {
+      logger.success("Seeds applied successfully");
+    }
+    logSection3("Database: Production Preview (dry-run)");
+    logger.info("Running: pnpm exec runa db apply production --check");
+  },
+  "postSeedPr.observability.collectSchemaStats": (ctx, logger) => {
+    if (ctx.productionPreview?.executed) {
+      if (ctx.productionPreview.hasChanges) {
+        logger.info("Production preview: schema changes detected");
+      } else {
+        logger.success("Production preview: no schema changes");
+      }
+    }
+    logSection3("Database: Collect Schema Statistics");
+    logger.info("Comparing Local/CI/Production schemas...");
+  },
+  "postSeedPr.execution.staticChecks": (ctx, logger) => {
+    if (ctx.rolesSetup) {
+      logger.success("Database roles configured");
+    }
+    logSection3("Static Checks: type-check + lint (parallel)");
+    logger.info("Running: pnpm type-check || pnpm lint");
+  },
+  "postSeedPr.execution.buildAndPlaywright": (ctx, logger) => {
+    if (ctx.staticChecksPassed) {
+      logger.success("Static checks passed");
+    }
+    logSection3("Build: App Build + Playwright Install (parallel)");
+    logger.info("Running: pnpm build || pnpm exec playwright install chromium");
+  },
+  "postSeedPr.execution.appStart": (ctx, logger) => {
+    if (ctx.appBuildPassed) {
+      logger.success("App build completed");
+    }
+    if (ctx.manifestGenerated) {
+      logger.success("Manifest generated (Layer 3 ready)");
+    } else if (ctx.manifestGenerated === false) {
+      logger.warn("Manifest generation failed (Layer 3 may be skipped)");
+    }
+    if (ctx.playwrightInstalled) {
+      logger.success("Playwright browsers installed");
+    }
+    logSection3("Start Application");
+    logger.info(`Starting app on port ${ctx.app?.port ?? 3e3}...`);
+  },
+  "postSeedPr.execution.capabilities": (ctx, logger) => {
+    if (ctx.appStarted) {
+      logger.success(`App started at ${ctx.baseUrl ?? "http://localhost:3000"}`);
+    }
+    logSection3("Detect Test Capabilities");
+  },
+  "postSeedPr.execution.runCoreTests": (ctx, logger) => {
+    const coreLayers = ctx.selectedLayers.filter((l) => l !== 4);
+    logSection3(`Core Tests: Layer ${coreLayers.join(", ")}`);
+    logger.info(`Running core layers: ${coreLayers.map((l) => `test layer${l}`).join(", ")}`);
+  },
+  "postSeedPr.execution.e2ePhase": (_ctx, logger) => {
+    logSection3("E2E Phase: Layer 4 + Intermediate Comment");
+    logger.info("Running Layer 4 E2E tests (parallel with intermediate PR comment)");
+  },
   productionPreview: (ctx, logger) => {
     if (ctx.seedsApplied) {
       logger.success("Seeds applied successfully");
@@ -9260,7 +9984,7 @@ async function runCiPrCommand(options) {
     { id: "setup", description: "Start local Supabase instance" },
     {
       id: "db",
-      description: "db apply \u2192 db seed \u2192 production preview \u2192 schema stats \u2192 db:setup-roles"
+      description: "db apply \u2192 db seed \u2192 (production preview \u2225 schema stats \u2225 db:setup-roles)"
     },
     ...skipStaticChecks ? [] : [{ id: "static", description: "pnpm type-check + pnpm lint (parallel)" }],
     ...skipBuild ? [] : [{ id: "build", description: "pnpm build \u2192 manifest:generate + playwright install" }],