@runa-ai/runa-cli 0.5.72 → 0.7.0

package/dist/template-check-3P4HZXVY.js

@@ -0,0 +1,1944 @@
+#!/usr/bin/env node
+import { createRequire } from 'module';
+import { getErrorMessage } from './chunk-IBVVGH6X.js';
+import { findRepoRoot } from './chunk-3WDV32GA.js';
+import { createMachineStateChangeLogger } from './chunk-5FT3F36G.js';
+import { getOutputFormatFromEnv } from './chunk-HKUWEGUX.js';
+import { __export, __esm, init_esm_shims, __require, __toCommonJS } from './chunk-VRXHCR5K.js';
+import { createCLILogger, CLIError } from '@runa-ai/runa';
+import { Command } from 'commander';
+import { fromPromise, setup, assign, createActor } from 'xstate';
+import * as fs2 from 'fs';
+import * as path2 from 'path';
+
+createRequire(import.meta.url);
+
+// src/commands/template-check/types.ts
+var types_exports = {};
+__export(types_exports, {
+  calculateSummary: () => calculateSummary,
+  createInitialContext: () => createInitialContext,
+  createOutput: () => createOutput
+});
+function createInitialContext(input, repoRoot) {
+  return {
+    input,
+    repoRoot,
+    templateDir: `${repoRoot}/packages/runa-templates/templates`,
+    inventory: null,
+    results: [],
+    startTime: Date.now(),
+    error: null
+  };
+}
+function calculateSummary(results) {
+  const total = results.length;
+  const identical = results.filter(
+    (r) => r.status === "identical" || r.status === "renamed" || r.status === "intentionally-different"
+  ).length;
+  const diff = results.filter((r) => r.status === "diff").length;
+  const runaOnly = results.filter((r) => r.status === "runa-only").length;
+  const templateOnly = results.filter((r) => r.status === "template-only").length;
+  const expectedOnly = results.filter(
+    (r) => r.status === "expected-runa-only" || r.status === "expected-template-only"
+  ).length;
+  return {
+    total,
+    identical,
+    diff,
+    runaOnly,
+    templateOnly,
+    expectedOnly,
+    identicalPercent: total > 0 ? Math.round(identical / total * 1e3) / 10 : 100
+  };
+}
+function createOutput(context) {
+  const durationMs = Date.now() - context.startTime;
+  const summary = calculateSummary(context.results);
+  const hasUnexpectedDiffs = summary.diff > 0 || summary.runaOnly > 0 || summary.templateOnly > 0;
+  return {
+    success: !context.error && !hasUnexpectedDiffs,
+    exitCode: context.error ? 2 : hasUnexpectedDiffs ? 1 : 0,
+    results: context.results,
+    summary,
+    error: context.error ?? void 0,
+    durationMs
+  };
+}
+var init_types = __esm({
+  "src/commands/template-check/types.ts"() {
+    init_esm_shims();
+  }
+});
+
+// src/commands/template-check/index.ts
+init_esm_shims();
+
+// src/commands/template-check/commands/template-check.ts
+init_esm_shims();
+
+// src/commands/template-check/machine.ts
+init_esm_shims();
+
+// src/commands/template-check/actors/index.ts
+init_esm_shims();
+
+// src/commands/template-check/actors/compare.ts
+init_esm_shims();
+
+// src/commands/template-check/utils/diff-analyzer.ts
+init_esm_shims();
+
+// src/commands/template-check/utils/normalizer.ts
+init_esm_shims();
+
+// src/commands/template-check/config.ts
+init_esm_shims();
+var CODE_EXTENSIONS = [".ts", ".tsx", ".yml", ".yaml"];
+var RUNA_ONLY_FILES = [
+  // === Root Config ===
+  "runa.config.ts",
+  // runa-repo dogfooding config
+  // === Documentation ===
+  ".claude/rules/dogfooding.md",
+  // SDK development philosophy
+  // === runa-repo Domain Schemas (runa-specific business logic) ===
+  "supabase/schemas/declarative/10_accounts.sql",
+  "supabase/schemas/declarative/20_repos.sql",
+  "supabase/schemas/declarative/30_pipelines.sql",
+  "supabase/schemas/declarative/40_projects.sql",
+  "supabase/schemas/declarative/80_analytics.sql",
+  "supabase/schemas/declarative/90_test_execution.sql",
+  "supabase/schemas/idempotent/20_security_hardening.sql",
+  // === runa-repo Workflows (SDK release & internal) ===
+  ".github/workflows/auto-changeset.yml",
+  ".github/workflows/changesets.yml",
+  ".github/workflows/license-check.yml",
+  // SDK license compatibility check
+  ".github/workflows/package-test.yml",
+  ".github/workflows/publish-packages.yml",
+  ".github/workflows/publish-templates.yml",
+  ".github/workflows/publish-github-packages.yml",
+  // SDK package publishing
+  ".github/workflows/publish-npmjs.yml",
+  // SDK package publishing (npmjs)
+  ".github/workflows/runa-templates.yml",
+  // Template validation (pj-repos don't have templates)
+  // === runa-repo Specific Scripts ===
+  "packages/database/scripts/db-sync-partition.ts",
+  // Partition defense (TODO: add to template)
+  "packages/database/scripts/db-sync-partition.test.ts",
+  // Partition defense tests
+  "packages/database/scripts/check-plpgsql.ts",
+  "packages/database/scripts/db-sync-apply-steps.test.ts",
+  "packages/database/scripts/db-sync-codegen-runtime.test.ts",
+  "packages/database/scripts/db-sync-db-state.test.ts",
+  "packages/database/scripts/db-sync-local-url.test.ts",
+  "packages/database/scripts/db-sync-pg-schema-diff.test.ts",
+  "packages/database/scripts/db-sync-schema-discovery.test.ts",
+  "packages/database/scripts/db-sync-schema-sort.ts",
+  "packages/database/scripts/db-sync-seeds-runtime.test.ts",
+  "packages/database/scripts/seed-writer.test.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",
+  "packages/database/tests/02_constraint-helpers.sql",
+  "packages/database/tests/03_rls-helpers.sql",
+  "packages/database/tests/04_behavior-tests.sql",
+  "packages/database/tests/05_supabase-compat.sql",
+  "packages/database/tests/10_behavior_tests.sql",
+  "supabase/tests/00_system-schemas.sql",
+  "supabase/tests/01_table-helpers.sql",
+  "supabase/tests/02_constraint-helpers.sql",
+  "supabase/tests/03_rls-helpers.sql",
+  "supabase/tests/04_behavior-tests.sql",
+  "supabase/tests/05_supabase-compat.sql",
+  // === runa-repo Vitest Configs ===
+  "config/vitest/vitest.config.cli.ts",
+  "config/vitest/vitest.config.e2e.ts",
+  "config/vitest/vitest.config.runa.ts",
+  "config/vitest/layer3-global-setup.ts",
+  // === runa-repo Database Extension Types ===
+  // Note: schema.ts, relations.ts, entities.ts moved to INTENTIONALLY_DIFFERENT_FILES
+  // (templates have stub versions, runa-repo has actual generated code)
+  "packages/database/src/types/extensions/index.ts",
+  "packages/database/src/types/extensions/pgvector.ts",
+  "packages/database/src/types/extensions/postgis.ts"
+];
+var TEMPLATE_ONLY_FILES = [
+  // === Documentation & Setup ===
+  ".claude/rules/sdk/setup.md",
+  // pj-repo setup guide
+  ".claude/rules/local/README.md",
+  // Local rules customization guide
+  ".claude/commands/local/README.md",
+  // Local commands guide
+  ".claude/skills/local/README.md",
+  // Local skills guide
+  // === pj-repo Starter Files ===
+  ".env.example",
+  // Environment template
+  ".runa/ci.config.json",
+  // CI configuration
+  "scripts/load-env.ts",
+  // Environment loader
+  "global-setup.ts",
+  // Root global setup (runa-repo uses config/playwright/global-setup.ts)
+  // === apps/web/ (pj-repo starter app) ===
+  // Note: runa-repo uses apps/dashboard/, templates provide apps/web/ starter
+  "apps/web/package.json",
+  "apps/web/tsconfig.json",
+  "apps/web/next.config.ts",
+  "apps/web/proxy.ts",
+  // Next.js 16+ proxy (replaces middleware.ts)
+  "apps/web/app/layout.tsx",
+  "apps/web/app/page.tsx",
+  "apps/web/app/(protected)/layout.tsx",
+  // Auth guard layout
+  "apps/web/app/(protected)/dashboard/page.tsx",
+  // Protected dashboard
+  "apps/web/app/(public)/login/page.tsx",
+  // Public login page
+  "apps/web/app/auth/callback/route.ts",
+  // OAuth callback handler
+  "apps/web/lib/supabase/index.ts",
+  // Supabase client exports
+  "apps/web/lib/supabase/client.ts",
+  // Browser client
+  "apps/web/lib/supabase/server.ts",
+  // Server client
+  "apps/web/lib/supabase/env.ts",
+  // Environment resolution
+  // === packages/api-client (pj-repo starter) ===
+  "packages/api-client/package.json",
+  "packages/api-client/tsconfig.json",
+  "packages/api-client/index.ts",
+  "packages/api-client/mutations/example.ts",
+  "packages/api-client/queries/example.ts",
+  "packages/api-client/tests/queries.test.tsx",
+  // === Optional Database Extensions ===
+  "packages/database/extensions/pgvector.sql",
+  "packages/database/extensions/postgis.sql",
+  // === pj-repo Universal Tests ===
+  "packages/database/tests/10_universal_constraints.test.sql",
+  "packages/database/tests/40_universal_security_rls.test.sql",
+  "packages/database/tests/50_universal_data_integrity.test.sql",
+  "packages/database/tests/90_behavior_patterns.test.sql",
+  "packages/database/scripts/run-pgtap-tests.ts",
+  // === pj-repo Seed Helpers ===
+  "supabase/migrations/00000000000000_extensions.sql",
+  "supabase/seeds/data/00_auth_users.sql",
+  "supabase/seeds/helpers/00_seed_helpers.sql",
+  "supabase/seeds/helpers/99_sequences.sql",
+  // Note: local.sql, preview.sql, production.sql are NOT allowed (ci.sql only)
+  "supabase/tests/00_test-helpers.sql"
+];
+var PLACEHOLDER_PATTERNS = {
+  // === Package & Import References ===
+  // Package references: @runa-ai/runa, @runa-ai/runa-cli, etc.
+  PACKAGE_REF: {
+    pattern: /@runa-ai\/runa(-\w+)?/g,
+    replacement: "{{PACKAGE_REF}}"
+  },
+  // Internal SDK paths (runa-repo uses direct paths, pj-repo uses package imports)
+  // Example: ../../packages/sdk/src/test/runtime/config/runa-config.js
+  INTERNAL_SDK_PATH: {
+    pattern: /['"]\.\.\/+packages\/sdk\/src\/[^'"]+['"]/g,
+    replacement: "'{{SDK_IMPORT}}'"
+  },
+  // Path aliases: @/database, @/machines, etc.
+  PATH_ALIAS: {
+    pattern: /@\/(\w+)/g,
+    replacement: "{{PATH_ALIAS}}/$1"
+  },
+  // === Schema & Database References ===
+  // Schema.table references
+  SCHEMA_TABLE: {
+    pattern: /\b(accounts|repos|pipelines|identity|products|orders)\.(clients|repositories|webhooks|users|tenants|items|purchases)\b/g,
+    replacement: "{{SCHEMA}}.{{TABLE}}"
+  },
+  // Drizzle table names
+  DRIZZLE_TABLE: {
+    pattern: /\b(clients|repositories|webhooks|users|tenants|items)In(Accounts|Repos|Pipelines|Identity|Products|Orders)\b/g,
+    replacement: "{{DRIZZLE_TABLE}}"
+  },
+  // Scope column names
+  SCOPE_COLUMN: {
+    pattern: /\b(client_id|tenant_id|scope_id|org_id|organization_id|workspace_id)\b/g,
+    replacement: "{{SCOPE_COLUMN}}"
+  },
+  // === Comment Differences ===
+  // Workspace type: "runa workspace" vs "pj-repo workspace"
+  WORKSPACE_TYPE: {
+    pattern: /\b(runa|pj-repo|the)\s+workspace\b/gi,
+    replacement: "{{REPO_TYPE}} workspace"
+  },
+  // Config purpose: Dogfooding vs Generated
+  CONFIG_PURPOSE: {
+    pattern: /\(Dogfooding\)|\(Generated by:.*?\)/g,
+    replacement: "({{CONFIG_TYPE}})"
+  },
+  // File path comments (normalize path styles)
+  // e.g., "config/vitest/env" vs "./config/vitest/env"
+  RELATIVE_PATH_PREFIX: {
+    pattern: /(?:path\.resolve\(__dirname,\s*)?['"]\.\/([^'"]+)['"]\)?|['"]([^'"]+)['"]/g,
+    replacement: "'{{PATH}}'"
+  },
+  // === Metadata ===
+  // Version numbers
+  VERSION: {
+    pattern: /Version:\s*[\d.]+/gi,
+    replacement: "Version: {{VERSION}}"
+  },
+  // Timestamps in docs
+  DATE: {
+    pattern: /\*\*(Created|Updated)\*\*:\s*\d{4}-\d{2}-\d{2}/g,
+    replacement: "**$1**: {{DATE}}"
+  }
+};
+var INTENTIONALLY_DIFFERENT_FILES = [
+  // === Config Files ===
+  "pnpm-workspace.yaml",
+  // runa-repo has "admin" workspace (internal)
+  "runa.config.ts",
+  // Dogfooding vs Generated comments
+  "vitest.config.ts",
+  // Internal paths vs package imports
+  "vitest.global-setup.ts",
+  // Vercel pull vs generic setup
+  "playwright.config.ts",
+  // Internal paths + ESM/CJS fallback in template
+  "config/vitest/layer3-global-setup.ts",
+  // Dogfooding layer 3 setup differs
+  "config/vitest/vitest.config.layer1.ts",
+  // Dogfooding layer 1 test patterns differ
+  "config/vitest/vitest.config.layer3.ts",
+  // Internal SDK path vs package import
+  // === Workflow Files ===
+  // runa-repo uses hardcoded organization URLs, templates use secrets
+  ".github/workflows/runa.yml",
+  // r06-corp/runa vs ${{ secrets.* }}
+  ".github/workflows/deploy-db.yml",
+  // github-token parameter differences
+  // === GitHub Actions ===
+  ".github/actions/setup-playwright-deps/action.yml",
+  // Comment: "runa-repo and pj-repos" vs "pj-repos"
+  ".github/actions/setup-node-pnpm/action.yml",
+  // Comment: SSOT note vs DRY principle
+  ".github/actions/setup-runa-cli/action.yml",
+  // Comment: Zero-PAT description differences
+  // === Database Auto-Generated vs Stub Files ===
+  // runa-repo has actual drizzle-kit generated code, templates have stub files
+  // Stub files are placeholders that get replaced by `runa db sync`
+  "packages/database/src/schema/schema.ts",
+  // Generated vs stub
+  "packages/database/src/schema/relations.ts",
+  // Generated vs stub
+  "packages/database/src/types/entities.ts",
+  // Generated vs stub
+  "packages/database/scripts/db-sync.ts",
+  // Template has formatGeneratedCode(), runa-repo doesn't
+  // === Database Scripts ===
+  // runa-repo has domain-specific tables (accounts.clients, repos.repositories, etc.)
+  // while templates use generic examples
+  "packages/database/drizzle.config.ts",
+  // Different schema paths
+  "packages/database/src/index.ts",
+  // Different schema exports
+  "packages/database/src/schema/index.ts",
+  // Different table exports
+  "packages/database/scripts/db-sync-codegen-runtime.ts",
+  // Dogfooding codegen runtime differs
+  "packages/database/scripts/db-sync-codegen.ts",
+  // PostGIS cleanup differs
+  "packages/database/scripts/db-sync-local-url.ts",
+  // Local DB discovery differs
+  "packages/database/scripts/db-sync-pg-schema-diff.ts",
+  // Direct apply helpers differ
+  "packages/database/scripts/db-sync-schema-discovery.ts",
+  // Schema cache behavior differs
+  "packages/database/scripts/db-sync-seeds-runtime.ts",
+  // Seed runtime orchestration differs
+  "packages/database/scripts/generate-seeds.ts",
+  // runa-specific seed logic
+  "packages/database/scripts/validate-schema-consistency.ts",
+  // runa-specific validation
+  "packages/database/scripts/seed-requirements.ts",
+  // runa-specific seed requirements
+  "packages/database/scripts/seed-semantic-rules.ts",
+  // runa-specific semantic rules
+  "packages/database/scripts/seed-writer.ts",
+  // runa-specific seed writer
+  "packages/database/scripts/seed-media/index.ts",
+  // runa-specific media seeds
+  "packages/database/scripts/seed-engines/auto-seed-generator.ts",
+  // Dogfooding seed generation differs
+  "packages/database/scripts/seed-engines/auto-seed-generator.test.ts",
+  // runa-specific tests
+  "packages/database/scripts/seed-engines/constants.test.ts",
+  // runa-specific tests
+  "packages/database/scripts/seed-engines/db-schema-analyzer.ts",
+  // Re-export order differences
+  "packages/database/scripts/seed-engines/generators/locale.ts",
+  // Import style differences
+  "packages/database/scripts/seed-utils.ts",
+  // Dogfooding seed utils differ
+  "packages/database/scripts/setup-db-roles.ts",
+  // Role setup variations
+  "packages/database/src/zod/index.ts",
+  // Auto-generated, schema-specific exports
+  // === Skills/Prompts ===
+  // Minor wording differences in CLI vs SDK references
+  "docs/prompts/AUDIT-GEN.yml",
+  // "Official CLI + runa" vs "Official CLI priority"
+  "docs/prompts/SPEC-PATTERNS.yml",
+  // Spec pattern differences
+  ".claude/skills/audit/templates/AUDIT-GEN.yml",
+  // Same as above
+  // === apps/api vs packages/api path differences ===
+  // runa-repo uses apps/api (internal), templates use packages/api (standard pj-repo pattern)
+  "docs/prompts/REFACTOR-GEN.yml",
+  // apps/api vs packages/api
+  "docs/prompts/REFACTOR-PATTERNS.yml",
+  // apps/api vs packages/api
+  "docs/prompts/SPEC-TEMPLATE-PRD.yml",
+  // apps/api vs packages/api
+  "docs/prompts/SPEC-TEMPLATE-MACHINE.yml",
+  // apps/api vs packages/api
+  ".claude/skills/refactor/templates/REFACTOR-GEN.yml",
+  // apps/api vs packages/api
+  ".claude/skills/refactor/templates/REFACTOR-PATTERNS.yml",
+  // apps/api vs packages/api
+  ".claude/skills/spec/templates/RESEARCH-CHECKLIST.yml"
+  // apps/api vs packages/api
+];
+
+// src/commands/template-check/utils/normalizer.ts
+function normalizeContent(content) {
+  let normalized = content;
+  for (const [_key, { pattern, replacement }] of Object.entries(PLACEHOLDER_PATTERNS)) {
+    normalized = normalized.replace(pattern, replacement);
+  }
+  normalized = normalized.replace(/[ \t]+$/gm, "");
+  normalized = normalized.replace(/\n{3,}/g, "\n\n");
+  if (!normalized.endsWith("\n")) {
+    normalized += "\n";
+  }
+  return normalized;
+}
+function isExpectedRunaOnly(runaPath) {
+  return RUNA_ONLY_FILES.includes(runaPath);
+}
+function isExpectedTemplateOnly(templatePath) {
+  return TEMPLATE_ONLY_FILES.includes(templatePath);
+}
+function isIntentionallyDifferent(filePath) {
+  return INTENTIONALLY_DIFFERENT_FILES.includes(filePath);
+}
+function isCodeFile(filePath) {
+  const ext = filePath.slice(filePath.lastIndexOf("."));
+  return CODE_EXTENSIONS.includes(ext);
+}
+function countLines(content) {
+  return content.split("\n").length;
+}
+
+// src/commands/template-check/utils/diff-analyzer.ts
+function compareFiles(runaContent, templateContent) {
+  const normalizedRuna = normalizeContent(runaContent);
+  const normalizedTemplate = normalizeContent(templateContent);
+  if (normalizedRuna === normalizedTemplate) {
+    return {
+      identical: true,
+      ahead: "equal",
+      lineDiff: "\xB10",
+      addedLines: 0,
+      removedLines: 0
+    };
+  }
+  const runaLines = countLines(normalizedRuna);
+  const templateLines = countLines(normalizedTemplate);
+  const lineDiff = runaLines - templateLines;
+  const ahead = determineAhead(normalizedRuna, normalizedTemplate, runaLines, templateLines);
+  return {
+    identical: false,
+    ahead,
+    lineDiff: formatLineDiff(lineDiff),
+    addedLines: Math.max(0, lineDiff),
+    removedLines: Math.max(0, -lineDiff)
+  };
+}
+function determineAhead(runaContent, templateContent, runaLines, templateLines) {
+  const runaVersion = extractVersion(runaContent);
+  const templateVersion = extractVersion(templateContent);
+  if (runaVersion && templateVersion && runaVersion !== templateVersion) {
+    return runaVersion > templateVersion ? "runa" : "template";
+  }
+  const lineDiff = Math.abs(runaLines - templateLines);
+  if (lineDiff > 10) {
+    return runaLines > templateLines ? "runa" : "template";
+  }
+  const runaDate = extractUpdateDate(runaContent);
+  const templateDate = extractUpdateDate(templateContent);
+  if (runaDate && templateDate && runaDate !== templateDate) {
+    return runaDate > templateDate ? "runa" : "template";
+  }
+  return "diverged";
+}
+function buildDiffHunkMeta(change, contextSize, runaLineCount) {
+  const contextStart = Math.max(0, change.currentStart - contextSize);
+  const hasContextBefore = contextStart < change.currentStart;
+  const runaStart = hasContextBefore ? contextStart : change.currentStart;
+  const runaCount = change.currentEnd - runaStart + contextSize;
+  const templateCount = change.templateEnd - change.templateStart + (hasContextBefore ? contextSize : 0);
+  return {
+    header: `@@ -${runaStart + 1},${runaCount} +${change.templateStart + 1},${templateCount} @@`,
+    contextStart,
+    contextEnd: Math.min(runaLineCount, change.currentEnd + contextSize)
+  };
+}
+function appendPrefixedLines(diffLines, sourceLines, start, end, prefix, totalLines, maxLines) {
+  for (let index = start; index < end && totalLines < maxLines; index++) {
+    diffLines.push(`${prefix}${sourceLines[index] ?? ""}`);
+    totalLines++;
+  }
+  return totalLines;
+}
+function generateUnifiedDiff(runaContent, templateContent, options = {}) {
+  const maxLines = options.maxLines ?? 50;
+  const runaLabel = options.runaLabel ?? "runa";
+  const templateLabel = options.templateLabel ?? "template";
+  const runaLines = runaContent.split("\n");
+  const templateLines = templateContent.split("\n");
+  const contextSize = 2;
+  const changes = findDiffChanges(runaLines, templateLines);
+  if (changes.length === 0) return "";
+  const diffLines = [`--- ${runaLabel}`, `+++ ${templateLabel}`];
+  let totalLines = 0;
+  for (let idx = 0; idx < changes.length; idx++) {
+    if (totalLines >= maxLines) {
+      diffLines.push(`... (${changes.length - idx} more change(s) truncated)`);
+      break;
+    }
+    const change = changes[idx];
+    const hunkMeta = buildDiffHunkMeta(change, contextSize, runaLines.length);
+    diffLines.push(hunkMeta.header);
+    totalLines = appendPrefixedLines(
+      diffLines,
+      runaLines,
+      hunkMeta.contextStart,
+      change.currentStart,
+      " ",
+      totalLines,
+      maxLines
+    );
+    totalLines = appendPrefixedLines(
+      diffLines,
+      runaLines,
+      change.currentStart,
+      change.currentEnd,
+      "-",
+      totalLines,
+      maxLines
+    );
+    totalLines = appendPrefixedLines(
+      diffLines,
+      templateLines,
+      change.templateStart,
+      change.templateEnd,
+      "+",
+      totalLines,
+      maxLines
+    );
+    totalLines = appendPrefixedLines(
+      diffLines,
+      runaLines,
+      change.currentEnd,
+      hunkMeta.contextEnd,
+      " ",
+      totalLines,
+      maxLines
+    );
+  }
+  return diffLines.join("\n");
+}
+function findDiffChanges(currentLines, templateLines) {
+  const changes = [];
+  let i = 0;
+  let j = 0;
+  while (i < currentLines.length || j < templateLines.length) {
+    if (i < currentLines.length && j < templateLines.length && currentLines[i] === templateLines[j]) {
+      i++;
+      j++;
+      continue;
+    }
+    const changeStart = { current: i, template: j };
+    while (i < currentLines.length && j < templateLines.length && currentLines[i] !== templateLines[j]) {
+      const sync = tryResync(currentLines, templateLines, i, j);
+      i += sync.iOffset;
+      j += sync.jOffset;
+    }
+    if (i >= currentLines.length && j < templateLines.length) {
+      j = templateLines.length;
+    } else if (j >= templateLines.length && i < currentLines.length) {
+      i = currentLines.length;
+    }
+    changes.push({
+      currentStart: changeStart.current,
+      currentEnd: i,
+      templateStart: changeStart.template,
+      templateEnd: j
+    });
+  }
+  return changes;
+}
+function tryResync(currentLines, templateLines, i, j) {
+  const maxLookahead = 5;
+  for (let lookahead = 1; lookahead <= maxLookahead && i + lookahead < currentLines.length; lookahead++) {
+    if (currentLines[i + lookahead] === templateLines[j]) {
+      return { found: true, iOffset: lookahead, jOffset: 0 };
+    }
+  }
+  for (let lookahead = 1; lookahead <= maxLookahead && j + lookahead < templateLines.length; lookahead++) {
+    if (currentLines[i] === templateLines[j + lookahead]) {
+      return { found: true, iOffset: 0, jOffset: lookahead };
+    }
+  }
+  return { found: false, iOffset: 1, jOffset: 1 };
+}
+function extractVersion(content) {
+  const match = content.match(/(?:Version|version|v)[\s:]*(\d+(?:\.\d+)*)/i);
+  return match ? match[1] : null;
+}
+function extractUpdateDate(content) {
+  const match = content.match(/\*\*Updated\*\*:\s*(\d{4}-\d{2}-\d{2})/);
+  return match ? match[1] : null;
+}
+function formatLineDiff(diff) {
+  if (diff > 0) {
+    return `+${diff}`;
+  }
+  if (diff < 0) {
+    return String(diff);
+  }
+  return "\xB10";
+}
+
+// src/commands/template-check/actors/compare.ts
+function compareBothFiles(runaRelPath, templateRelPath, runaAbsPath, templateAbsPath, category, includeDiff) {
+  const runaContent = fs2.readFileSync(runaAbsPath, "utf-8");
+  const templateContent = fs2.readFileSync(templateAbsPath, "utf-8");
+  const comparison = compareFiles(runaContent, templateContent);
+  let status;
+  if (comparison.identical) {
+    status = runaRelPath !== templateRelPath ? "renamed" : "identical";
+  } else if (isIntentionallyDifferent(runaRelPath)) {
+    status = "intentionally-different";
+  } else {
+    status = "diff";
+  }
+  const result = {
+    runaPath: runaRelPath,
+    templatePath: templateRelPath,
+    category,
+    status,
+    ahead: comparison.identical ? void 0 : comparison.ahead,
+    lineDiff: comparison.identical ? void 0 : comparison.lineDiff
+  };
+  if (includeDiff && !comparison.identical) {
+    result.diffOutput = generateUnifiedDiff(runaContent, templateContent, {
+      maxLines: 30,
+      runaLabel: runaRelPath,
+      templateLabel: templateRelPath
+    });
+  }
+  return result;
+}
+function createRunaOnlyResult(runaRelPath, category) {
+  return {
+    runaPath: runaRelPath,
+    templatePath: null,
+    category,
+    status: isExpectedRunaOnly(runaRelPath) ? "expected-runa-only" : "runa-only"
+  };
+}
+function createTemplateOnlyResult(templateRelPath, category) {
+  return {
+    runaPath: null,
+    templatePath: templateRelPath,
+    category,
+    status: isExpectedTemplateOnly(templateRelPath) ? "expected-template-only" : "template-only"
+  };
+}
+function sortResults(results) {
+  results.sort((a, b) => {
+    if (a.category !== b.category) {
+      return a.category.localeCompare(b.category);
+    }
+    const pathA = a.runaPath ?? a.templatePath ?? "";
+    const pathB = b.runaPath ?? b.templatePath ?? "";
+    return pathA.localeCompare(pathB);
+  });
+}
+function filterResults(results, category) {
+  let filtered = results.filter((r) => {
+    const filePath = r.runaPath ?? r.templatePath ?? "";
+    return isCodeFile(filePath);
+  });
+  if (category) {
+    filtered = filtered.filter((r) => r.category === category);
+  }
+  return filtered;
+}
+var compareActor = fromPromise(async ({ input }) => {
+  const { inventory, repoRoot, templateDir, options } = input;
+  const results = [];
+  const processedKeys = /* @__PURE__ */ new Set();
+  for (const [key, runaRelPath] of inventory.runaByKey) {
+    processedKeys.add(key);
+    const runaFile = inventory.runaFiles.get(runaRelPath);
+    if (!runaFile) continue;
+    const templateRelPath = inventory.templateByKey.get(key);
+    if (templateRelPath) {
+      const templateFile = inventory.templateFiles.get(templateRelPath);
+      if (!templateFile) continue;
+      const result = compareBothFiles(
+        runaRelPath,
+        templateRelPath,
+        path2.join(repoRoot, runaRelPath),
+        path2.join(templateDir, templateRelPath),
+        runaFile.category,
+        options.diff ?? false
+      );
+      results.push(result);
+    } else {
+      results.push(createRunaOnlyResult(runaRelPath, runaFile.category));
+    }
+  }
+  for (const [key, templateRelPath] of inventory.templateByKey) {
+    if (processedKeys.has(key)) continue;
+    const templateFile = inventory.templateFiles.get(templateRelPath);
+    if (!templateFile) continue;
+    results.push(createTemplateOnlyResult(templateRelPath, templateFile.category));
+  }
+  sortResults(results);
+  return { results: filterResults(results, options.category) };
+});
+
+// src/commands/template-check/actors/discover.ts
+init_esm_shims();
+
+// src/commands/template-check/utils/path-mapping.ts
+init_esm_shims();
+var PATH_MAPPING_RULES = [
+  // ============================================================
+  // ROOT CONFIG FILES (HIGH PRIORITY)
+  // ============================================================
+  {
+    runa: "package.json",
+    template: "package.json",
+    category: "config"
+  },
+  {
+    runa: "turbo.json",
+    template: "turbo.json",
+    category: "config"
+  },
+  {
+    runa: "runa.config.ts",
+    template: "runa.config.ts",
+    category: "config"
+  },
+  {
+    runa: "tsconfig.json",
+    template: "tsconfig.json",
+    category: "config"
+  },
+  {
+    runa: "vitest.config.ts",
+    template: "vitest.config.ts",
+    category: "config"
+  },
+  {
+    runa: "vitest.global-setup.ts",
+    template: "vitest.global-setup.ts",
+    category: "config"
+  },
+  {
+    runa: "global-setup.ts",
+    template: "global-setup.ts",
+    category: "config"
+  },
+  {
+    runa: "playwright.config.ts",
+    template: "playwright.config.ts",
+    category: "config"
+  },
+  {
+    runa: "pnpm-workspace.yaml",
+    template: "pnpm-workspace.yaml",
+    category: "config"
+  },
+  {
+    runa: ".gitignore",
+    template: ".gitignore",
+    category: "config"
+  },
+  {
+    runa: ".squawk.toml",
+    template: ".squawk.toml",
+    category: "config"
+  },
+  {
+    runa: ".npmrc",
+    template: ".npmrc",
+    category: "config"
+  },
+  {
+    runa: ".env.example",
+    template: ".env.example",
+    category: "config"
+  },
+  // config/vitest/
+  {
+    runa: "config/vitest/*.ts",
+    template: "config/vitest/*.ts",
+    category: "config"
+  },
+  // scripts/
+  {
+    runa: "scripts/*.ts",
+    template: "scripts/*.ts",
+    category: "config"
+  },
+  // .runa/
+  {
+    runa: ".runa/*.json",
+    template: ".runa/*.json",
+    category: "config"
+  },
+  // ============================================================
+  // APPS/WEB (HIGH PRIORITY - FRONTEND CODE)
+  // ============================================================
+  {
+    runa: "apps/web/package.json",
+    template: "apps/web/package.json",
+    category: "config"
+  },
+  {
+    runa: "apps/web/tsconfig.json",
+    template: "apps/web/tsconfig.json",
+    category: "config"
+  },
+  {
+    runa: "apps/web/next.config.ts",
+    template: "apps/web/next.config.ts",
+    category: "config"
+  },
+  {
+    runa: "apps/web/app/**/*.tsx",
+    template: "apps/web/app/**/*.tsx",
+    category: "other"
+  },
+  {
+    runa: "apps/web/app/**/*.ts",
+    template: "apps/web/app/**/*.ts",
+    category: "other"
+  },
+  // ============================================================
+  // PACKAGES/DATABASE (HIGH PRIORITY - CODE)
+  // ============================================================
+  {
+    runa: "packages/database/package.json",
+    template: "packages/database/package.json",
+    category: "database"
+  },
+  {
+    runa: "packages/database/tsconfig.json",
+    template: "packages/database/tsconfig.json",
+    category: "database"
+  },
+  {
+    runa: "packages/database/biome.json",
+    template: "packages/database/biome.json",
+    category: "database"
+  },
+  {
+    runa: "packages/database/drizzle.config.ts",
+    template: "packages/database/drizzle.config.ts",
+    category: "database"
+  },
+  {
+    runa: "packages/database/src/*.ts",
+    template: "packages/database/src/*.ts",
+    category: "database"
+  },
+  {
+    runa: "packages/database/src/**/*.ts",
+    template: "packages/database/src/**/*.ts",
+    category: "database"
+  },
+  {
+    runa: "packages/database/scripts/**/*.ts",
+    template: "packages/database/scripts/**/*.ts",
+    category: "database"
+  },
+  {
+    runa: "packages/database/extensions/*.sql",
+    template: "packages/database/extensions/*.sql",
+    category: "database"
+  },
+  {
+    runa: "packages/database/tests/*.sql",
+    template: "packages/database/tests/*.sql",
+    category: "database"
+  },
+  // ============================================================
+  // SUPABASE (HIGH PRIORITY - SQL)
+  // ============================================================
+  {
+    runa: "supabase/config.toml",
+    template: "supabase/config.toml",
+    category: "database"
+  },
+  {
+    runa: "supabase/schemas/**/*.sql",
+    template: "supabase/schemas/**/*.sql",
+    category: "database"
+  },
+  {
+    runa: "supabase/seeds/*.sql",
+    template: "supabase/seeds/*.sql",
+    category: "database"
+  },
+  {
+    runa: "supabase/seeds/**/*.sql",
+    template: "supabase/seeds/**/*.sql",
+    category: "database"
+  },
+  {
+    runa: "supabase/migrations/*.sql",
+    template: "supabase/migrations/*.sql",
+    category: "database"
+  },
+  {
+    runa: "supabase/tests/*.sql",
+    template: "supabase/tests/*.sql",
+    category: "database"
+  },
+  // ============================================================
+  // GITHUB ACTIONS & WORKFLOWS (HIGH PRIORITY)
+  // ============================================================
+  {
+    runa: ".github/workflows/*.yml",
+    template: ".github/workflows/*.yml",
+    category: "workflows"
+  },
+  {
+    runa: ".github/actions/**/action.yml",
+    template: ".github/actions/**/action.yml",
+    category: "workflows"
+  },
+  // ============================================================
+  // HUSKY (GIT HOOKS)
+  // ============================================================
+  {
+    runa: ".husky/pre-commit",
+    template: ".husky/pre-commit",
+    category: "config"
+  },
+  {
+    runa: ".husky/pre-push",
+    template: ".husky/pre-push",
+    category: "config"
+  },
+  {
+    runa: ".husky/_common.sh",
+    template: ".husky/_common.sh",
+    category: "config"
+  },
+  // ============================================================
+  // PACKAGES/API-CLIENT (CODE)
+  // ============================================================
+  {
+    runa: "packages/api-client/package.json",
+    template: "packages/api-client/package.json",
+    category: "other"
+  },
+  {
+    runa: "packages/api-client/tsconfig.json",
+    template: "packages/api-client/tsconfig.json",
+    category: "other"
+  },
+  {
+    runa: "packages/api-client/**/*.ts",
+    template: "packages/api-client/**/*.ts",
+    category: "other"
+  },
+  {
+    runa: "packages/api-client/**/*.tsx",
+    template: "packages/api-client/**/*.tsx",
+    category: "other"
+  },
+  // ============================================================
+  // .CLAUDE DIRECTORY (LOWER PRIORITY)
+  // Note: Templates use _claude/ to avoid Claude Code detection in runa-repo.
+  // At runa init/upgrade time, _claude/ is renamed to .claude/.
+  // ============================================================
+  {
+    runa: ".claude/settings.json",
+    template: "_claude/settings.json",
+    category: "config"
+  },
+  {
+    runa: ".claude/rules/*.md",
+    template: "_claude/rules/sdk/*.md",
+    category: "rules",
+    rename: {
+      "code-quality.md": "quality.md",
+      "core-philosophy.md": "core.md",
+      "pj-repo-compatibility.md": "pj-repo-compat.md"
+    }
+  },
+  {
+    runa: ".claude/agents/*.md",
+    template: "_claude/agents/sdk/*.md",
+    category: "agents"
+  },
+  // Skills with SKILL.md (explicit paths instead of ** wildcard for reliable matching)
+  {
+    runa: ".claude/skills/audit/SKILL.md",
+    template: "_claude/skills/sdk/audit/SKILL.md",
+    category: "skills"
+  },
+  {
+    runa: ".claude/skills/refactor/SKILL.md",
+    template: "_claude/skills/sdk/refactor/SKILL.md",
+    category: "skills"
+  },
+  {
+    runa: ".claude/skills/spec/SKILL.md",
+    template: "_claude/skills/sdk/spec/SKILL.md",
+    category: "skills"
+  },
+  // Skills with templates/*.yml
+  {
+    runa: ".claude/skills/audit/templates/*.yml",
+    template: "_claude/skills/sdk/audit/templates/*.yml",
+    category: "skills"
+  },
+  {
+    runa: ".claude/skills/refactor/templates/*.yml",
+    template: "_claude/skills/sdk/refactor/templates/*.yml",
+    category: "skills"
+  },
+  {
+    runa: ".claude/skills/spec/templates/*.yml",
+    template: "_claude/skills/sdk/spec/templates/*.yml",
+    category: "skills"
+  },
+  {
+    runa: ".claude/commands/*.md",
+    template: "_claude/commands/sdk/*.md",
+    category: "commands"
+  },
+  {
+    runa: ".claude/maps/*.md",
+    template: "_claude/maps/*.md",
+    category: "other"
+  },
+  // ============================================================
+  // .CODEX DIRECTORY (mirrors .claude policies for Codex)
+  // ============================================================
+  {
+    runa: ".codex/README.md",
+    template: "_codex/README.md",
+    category: "config"
+  },
+  {
+    runa: ".codex/AGENTS.md",
+    template: "_codex/AGENTS.md",
+    category: "config"
+  },
+  {
+    runa: ".codex/CODEX.md",
+    template: "_codex/CODEX.md",
+    category: "config"
+  },
+  {
+    runa: ".codex/config.toml",
+    template: "_codex/config.toml",
+    category: "config"
+  },
+  {
+    runa: ".codex/rules/devops.md",
+    template: "_codex/rules/devops.md",
+    category: "rules"
+  },
+  {
+    runa: ".codex/rules/permissions.toml",
+    template: "_codex/rules/permissions.toml",
+    category: "rules"
+  },
+  // ============================================================
+  // ROOT DOCUMENTATION (LOWEST PRIORITY)
+  // ============================================================
+  {
+    runa: "AGENTS.md",
+    template: "AGENTS.md",
+    category: "root-docs"
+  },
+  {
+    runa: "CLAUDE.md",
+    template: "CLAUDE.md",
+    category: "root-docs"
+  },
+  {
+    runa: "docs/prompts/*.md",
+    template: "docs/prompts/*.md",
+    category: "prompts"
+  },
+  {
+    runa: "docs/prompts/*.yml",
+    template: "docs/prompts/*.yml",
+    category: "prompts"
+  }
+];
+function getCategoryForPath(path3) {
+  for (const rule of PATH_MAPPING_RULES) {
+    if (matchGlobPattern(path3, rule.runa) || matchGlobPattern(path3, rule.template)) {
+      return rule.category;
+    }
+  }
+  return "other";
+}
+function normalizeTemplatePath(templatePath) {
+  return templatePath.replace(/^_claude\//, ".claude/").replace(".claude/rules/sdk/", ".claude/rules/").replace(".claude/agents/sdk/", ".claude/agents/").replace(".claude/skills/sdk/", ".claude/skills/").replace(".claude/commands/sdk/", ".claude/commands/");
+}
+function applyReverseRename(normalized, rule, isTemplate) {
+  if (!rule.rename) return normalized;
+  const ruleBasePath = rule.runa.replace("/*.md", "/").replace("/**/*.md", "/");
+  if (!normalized.startsWith(ruleBasePath)) return normalized;
+  for (const [runaName, templateName] of Object.entries(rule.rename)) {
+    if (isTemplate && normalized.endsWith(templateName)) {
+      return normalized.replace(templateName, runaName);
+    }
+  }
+  return normalized;
+}
+function generateComparisonKey(path3, isTemplate) {
+  let normalized = isTemplate ? normalizeTemplatePath(path3) : path3;
+  for (const rule of PATH_MAPPING_RULES) {
+    normalized = applyReverseRename(normalized, rule, isTemplate);
+  }
+  return normalized;
+}
+function matchGlobPattern(path3, pattern) {
+  const regexPattern = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, "<<DOUBLE_STAR>>").replace(/\*/g, "([^/]*)").replace(/<<DOUBLE_STAR>>/g, "(.*)");
+  const regex = new RegExp(`^${regexPattern}$`);
+  const match = path3.match(regex);
+  if (match) {
+    const subPath = match[1] ?? "";
+    return { matched: true, subPath };
+  }
+  return null;
+}
+
+// src/commands/template-check/actors/discover.ts
+var discoverActor = fromPromise(async ({ input }) => {
+  const { repoRoot, templateDir } = input;
+  const inventory = {
+    runaFiles: /* @__PURE__ */ new Map(),
+    templateFiles: /* @__PURE__ */ new Map(),
+    runaByKey: /* @__PURE__ */ new Map(),
+    templateByKey: /* @__PURE__ */ new Map()
+  };
+  for (const rule of PATH_MAPPING_RULES) {
+    const runaPattern = rule.runa;
+    const runaFiles = await globFiles(repoRoot, runaPattern);
+    for (const file of runaFiles) {
+      const relativePath = path2.relative(repoRoot, file.absolutePath);
+      const key = generateComparisonKey(relativePath, false);
+      inventory.runaFiles.set(relativePath, {
+        ...file,
+        relativePath,
+        category: rule.category
+      });
+      inventory.runaByKey.set(key, relativePath);
+    }
+  }
+  for (const rule of PATH_MAPPING_RULES) {
+    const templatePattern = rule.template;
+    const templateFiles = await globFiles(templateDir, templatePattern);
+    for (const file of templateFiles) {
+      const relativePath = path2.relative(templateDir, file.absolutePath);
+      const key = generateComparisonKey(relativePath, true);
+      inventory.templateFiles.set(relativePath, {
+        ...file,
+        relativePath,
+        category: rule.category
+      });
+      inventory.templateByKey.set(key, relativePath);
+    }
+  }
+  return {
+    inventory,
+    runaCount: inventory.runaFiles.size,
+    templateCount: inventory.templateFiles.size
+  };
+});
+async function globFiles(baseDir, pattern) {
+  const results = [];
+  const parts = pattern.split("/");
+  await walkAndMatch({
+    currentDir: baseDir,
+    patternParts: parts,
+    partIndex: 0,
+    results,
+    fullPattern: pattern
+  });
+  return results;
+}
+function addFileResult(entryPath, fullPattern, results) {
+  const stats = fs2.statSync(entryPath);
+  results.push({
+    absolutePath: entryPath,
+    size: stats.size,
+    category: getCategoryForPath(fullPattern)
+  });
+}
+async function processEntry(ctx, entryPath, isFile, isDirectory, isLastPart) {
+  if (isLastPart && isFile) {
+    addFileResult(entryPath, ctx.fullPattern, ctx.results);
+    return;
+  }
+  if (!isLastPart && isDirectory) {
+    await walkAndMatch({ ...ctx, currentDir: entryPath, partIndex: ctx.partIndex + 1 });
+  }
+}
+async function matchDoubleWildcard(ctx, entries) {
+  await walkAndMatch({ ...ctx, partIndex: ctx.partIndex + 1 });
+  for (const entry of entries) {
+    if (entry.isDirectory()) {
+      const subDir = path2.join(ctx.currentDir, entry.name);
+      await walkAndMatch({ ...ctx, currentDir: subDir });
+    }
+  }
+}
+async function matchSingleWildcard(ctx, entries, pattern, isLastPart) {
+  const regex = patternToRegex(pattern);
+  for (const entry of entries) {
+    if (regex.test(entry.name)) {
+      const entryPath = path2.join(ctx.currentDir, entry.name);
+      await processEntry(ctx, entryPath, entry.isFile(), entry.isDirectory(), isLastPart);
+    }
+  }
+}
+async function matchBraceExpansion(ctx, entries, pattern, isLastPart) {
+  const options = extractBraceOptions(pattern);
+  for (const option of options) {
+    for (const entry of entries) {
+      if (entry.name === option) {
+        const entryPath = path2.join(ctx.currentDir, entry.name);
+        await processEntry(ctx, entryPath, entry.isFile(), entry.isDirectory(), isLastPart);
+      }
+    }
+  }
+}
+async function matchLiteral(ctx, pattern, isLastPart) {
+  const entryPath = path2.join(ctx.currentDir, pattern);
+  if (!fs2.existsSync(entryPath)) return;
+  const stats = fs2.statSync(entryPath);
+  await processEntry(ctx, entryPath, stats.isFile(), stats.isDirectory(), isLastPart);
+}
+async function walkAndMatch(ctx) {
+  if (ctx.partIndex >= ctx.patternParts.length) return;
+  if (!fs2.existsSync(ctx.currentDir)) return;
+  const currentPattern = ctx.patternParts[ctx.partIndex];
+  const isLastPart = ctx.partIndex === ctx.patternParts.length - 1;
+  const entries = fs2.readdirSync(ctx.currentDir, { withFileTypes: true });
+  if (currentPattern === "**") {
+    await matchDoubleWildcard(ctx, entries);
+  } else if (currentPattern.includes("*")) {
+    await matchSingleWildcard(ctx, entries, currentPattern, isLastPart);
+  } else if (currentPattern.includes("{")) {
+    await matchBraceExpansion(ctx, entries, currentPattern, isLastPart);
+  } else {
+    await matchLiteral(ctx, currentPattern, isLastPart);
+  }
+}
+function patternToRegex(pattern) {
+  const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
+  return new RegExp(`^${escaped}$`);
+}
+function extractBraceOptions(pattern) {
+  const match = pattern.match(/\{([^}]+)\}/);
+  if (!match) return [pattern];
+  const options = match[1].split(",");
+  const prefix = pattern.slice(0, match.index);
+  const suffix = pattern.slice((match.index ?? 0) + match[0].length);
+  return options.map((opt) => prefix + opt.trim() + suffix);
+}
+
+// src/commands/template-check/actors/report.ts
+init_esm_shims();
+init_types();
+var CATEGORY_DISPLAY_NAMES = {
+  rules: "Rules (.claude/rules/)",
+  agents: "Agents (.claude/agents/)",
+  skills: "Skills (.claude/skills/)",
+  commands: "Commands (.claude/commands/)",
+  prompts: "Prompts (docs/prompts/)",
+  database: "Database (packages/database/scripts/)",
+  workflows: "Workflows (.github/workflows/)",
+  "root-docs": "Root Documentation",
+  config: "Configuration",
+  other: "Other"
+};
+var reportActor = fromPromise(async ({ input }) => {
+  const { results, options, durationMs } = input;
+  const summary = calculateSummary(results);
+  const byCategory = groupByCategory(results);
+  const actionsNeeded = collectActionsNeeded(results);
+  let jsonString;
+  if (options.json) {
+    jsonString = JSON.stringify(
+      {
+        success: summary.diff === 0 && summary.runaOnly === 0 && summary.templateOnly === 0,
+        summary,
+        results,
+        actionsNeeded,
+        durationMs
+      },
+      null,
+      2
+    );
+  }
+  return {
+    byCategory,
+    summary,
+    actionsNeeded,
+    jsonOutput: options.json,
+    jsonString
+  };
+});
+function groupByCategory(results) {
+  const categoryMap = /* @__PURE__ */ new Map();
+  for (const result of results) {
+    const existing = categoryMap.get(result.category) ?? [];
+    existing.push(result);
+    categoryMap.set(result.category, existing);
+  }
+  const reports = [];
+  for (const [category, categoryResults] of categoryMap) {
+    const identical = categoryResults.filter(
+      (r) => r.status === "identical" || r.status === "renamed" || r.status === "intentionally-different"
+    ).length;
+    const diff = categoryResults.filter((r) => r.status === "diff").length;
+    const runaOnly = categoryResults.filter((r) => r.status === "runa-only").length;
+    const templateOnly = categoryResults.filter((r) => r.status === "template-only").length;
+    const expectedOnly = categoryResults.filter(
+      (r) => r.status === "expected-runa-only" || r.status === "expected-template-only"
+    ).length;
+    reports.push({
+      category,
+      displayName: CATEGORY_DISPLAY_NAMES[category],
+      results: categoryResults,
+      identical,
+      diff,
+      runaOnly,
+      templateOnly,
+      expectedOnly
+    });
+  }
+  const categoryOrder = [
+    "rules",
+    "agents",
+    "skills",
+    "commands",
+    "prompts",
+    "database",
+    "workflows",
+    "root-docs",
+    "config",
+    "other"
+  ];
+  reports.sort((a, b) => {
+    return categoryOrder.indexOf(a.category) - categoryOrder.indexOf(b.category);
+  });
+  return reports;
+}
+function collectActionsNeeded(results) {
+  const actions = [];
+  for (const result of results) {
+    if (result.status === "diff" || result.status === "runa-only" || result.status === "template-only") {
+      actions.push({
+        path: result.runaPath ?? result.templatePath ?? "",
+        targetPath: result.runaPath && result.templatePath ? result.templatePath : null,
+        status: result.status,
+        ahead: result.ahead ?? null,
+        lineDiff: result.lineDiff ?? null,
+        diffOutput: result.diffOutput
+      });
+    }
+  }
+  return actions;
+}
+
+// src/commands/template-check/machine.ts
+init_types();
+var e2eMeta = {
+  idle: {
+    description: "Waiting for START event to begin template check",
+    severity: "non-critical",
+    observables: {
+      log: "Template Check"
+    },
+    assertions: ["expect(log).toContain('Template Check')", "expect(state).toBe('idle')"],
+    nextStates: ["discover"]
+  },
+  discover: {
+    description: "Scan runa-repo and pj-repo for template files",
+    severity: "blocking",
+    observables: {
+      log: "Discovering files",
+      fs: "packages/runa-templates/templates/ scanned"
+    },
+    assertions: [
+      "expect(log).toContain('Discovering files')",
+      "expect(ctx.inventory).toBeDefined()"
+    ],
+    nextStates: ["compare", "failed"]
+  },
+  compare: {
+    description: "Normalize content and compare template files",
+    severity: "blocking",
+    observables: {
+      log: "Comparing files"
+    },
+    assertions: ["expect(log).toContain('Comparing files')", "expect(ctx.results).toBeArray()"],
+    nextStates: ["report", "failed"]
+  },
+  report: {
+    description: "Generate comparison report and summary",
+    severity: "blocking",
+    observables: {
+      log: "Summary"
+    },
+    assertions: ["expect(log).toContain('Summary')"],
+    nextStates: ["done", "failed"]
+  },
+  done: {
+    description: "Template check completed",
+    severity: "final",
+    observables: {
+      log: "Summary",
+      exit: "0 (all identical) or 1 (differences found)"
+    },
+    assertions: ["expect(log).toContain('Summary')", "expect(exitCode).toBe(0).or.toBe(1)"],
+    nextStates: []
+  },
+  failed: {
+    description: "Template check failed with error",
+    severity: "final",
+    observables: {
+      log: "failed",
+      exit: 2
+    },
+    assertions: ["expect(log).toContain('failed')", "expect(exitCode).toBe(2)"],
+    nextStates: []
+  }
+};
+var syncCheckMachine = setup({
+  types: {},
+  actors: {
+    discover: discoverActor,
+    compare: compareActor,
+    report: reportActor
+  }
+}).createMachine({
+  id: "templateCheck",
+  initial: "idle",
+  context: ({ input }) => ({
+    input: input.input,
+    repoRoot: input.repoRoot,
+    templateDir: `${input.repoRoot}/packages/runa-templates/templates`,
+    inventory: null,
+    results: [],
+    startTime: Date.now(),
+    error: null
+  }),
+  states: {
+    // ============================================================
+    // Idle State
+    // ============================================================
+    idle: {
+      meta: { e2e: e2eMeta.idle },
+      on: {
+        START: { target: "discover" }
+      }
+    },
+    // ============================================================
+    // Discover Phase
+    // ============================================================
+    discover: {
+      meta: { e2e: e2eMeta.discover },
+      invoke: {
+        src: "discover",
+        input: ({ context }) => ({
+          repoRoot: context.repoRoot,
+          templateDir: context.templateDir
+        }),
+        onDone: {
+          target: "compare",
+          actions: assign({
+            inventory: ({ event }) => event.output.inventory
+          })
+        },
+        onError: {
+          target: "failed",
+          actions: assign({
+            error: ({ event }) => `Discovery failed: ${getErrorMessage(event.error)}`
+          })
+        }
+      }
+    },
+    // ============================================================
+    // Compare Phase
+    // ============================================================
+    compare: {
+      meta: { e2e: e2eMeta.compare },
+      invoke: {
+        src: "compare",
+        input: ({ context }) => ({
+          inventory: context.inventory,
+          repoRoot: context.repoRoot,
+          templateDir: context.templateDir,
+          options: context.input
+        }),
+        onDone: {
+          target: "report",
+          actions: assign({
+            results: ({ event }) => event.output.results
+          })
+        },
+        onError: {
+          target: "failed",
+          actions: assign({
+            error: ({ event }) => `Comparison failed: ${getErrorMessage(event.error)}`
+          })
+        }
+      }
+    },
+    // ============================================================
+    // Report Phase
+    // ============================================================
+    report: {
+      meta: { e2e: e2eMeta.report },
+      invoke: {
+        src: "report",
+        input: ({ context }) => ({
+          results: context.results,
+          options: context.input,
+          durationMs: Date.now() - context.startTime
+        }),
+        onDone: {
+          target: "done"
+          // Report output is used for rendering, not stored in context
+        },
+        onError: {
+          target: "failed",
+          actions: assign({
+            error: ({ event }) => `Report generation failed: ${getErrorMessage(event.error)}`
+          })
+        }
+      }
+    },
+    // ============================================================
+    // Final States
+    // ============================================================
+    done: {
+      meta: { e2e: e2eMeta.done },
+      type: "final"
+    },
+    failed: {
+      meta: { e2e: e2eMeta.failed },
+      type: "final"
+    }
+  },
+  output: ({ context }) => createOutput(context)
+});
+function getStateName(snapshot) {
+  return typeof snapshot.value === "string" ? snapshot.value : "unknown";
+}
+function isComplete(snapshot) {
+  return snapshot.status === "done";
+}
+
+// src/commands/template-check/commands/template-check.ts
+var stateLogHandlers = {
+  idle: (logger) => {
+    logger.section("Template Check");
+    logger.info("Comparing runa-repo with pj-repo templates...");
+  },
+  discover: (logger) => {
+    logger.info("Discovering files...");
+  },
+  compare: (logger) => {
+    logger.info("Comparing files...");
+  },
+  report: (_logger) => {
+  }
+};
+var logStateChange = createMachineStateChangeLogger({
+  getState: getStateName,
+  getContext: (snapshot) => snapshot.context,
+  handlers: stateLogHandlers,
+  shouldSkipState: (_state, _prevState, _context, extra) => {
+    return extra?.jsonMode === true || extra?.quietMode === true;
+  }
+});
+function handleStateChange(snapshot, prevState, logger, jsonMode, quietMode) {
+  logStateChange(snapshot, prevState, logger, { jsonMode, quietMode });
+}
+var CATEGORY_DISPLAY_NAMES2 = {
+  rules: "Rules (.claude/rules/)",
+  agents: "Agents (.claude/agents/)",
+  skills: "Skills (.claude/skills/)",
+  commands: "Commands (.claude/commands/)",
+  prompts: "Prompts (docs/prompts/)",
+  database: "Database (packages/database/scripts/)",
+  workflows: "Workflows (.github/workflows/)",
+  "root-docs": "Root Documentation",
+  config: "Configuration",
+  other: "Other"
+};
+var STATUS_ICONS = {
+  identical: "\u2705",
+  renamed: "\u{1F504}",
+  diff: "\u26A0\uFE0F",
+  "runa-only": "\u{1F535}",
+  "template-only": "\u{1F7E0}",
+  "expected-runa-only": "\u23ED\uFE0F",
+  "expected-template-only": "\u23ED\uFE0F",
+  "intentionally-different": "\u{1F4CC}"
+  // Expected to differ (dogfooding vs pj-repo)
+};
+var AHEAD_LABELS = {
+  runa: "runa ahead",
+  template: "template ahead",
+  diverged: "diverged",
+  equal: ""
+};
+var STATUS_SUFFIXES = {
+  "runa-only": "(unexpected - missing in template)",
+  "template-only": "(unexpected - missing in runa-repo)",
+  "expected-runa-only": "(expected - runa-repo only)",
+  "expected-template-only": "(expected - pj-repo only)",
+  renamed: "(file renamed, content identical)"
+};
+function getStatusSuffix(result) {
+  if (result.status === "diff") {
+    let suffix = result.lineDiff ?? "";
+    if (result.ahead && AHEAD_LABELS[result.ahead]) {
+      suffix += ` (${AHEAD_LABELS[result.ahead]})`;
+    }
+    return suffix;
+  }
+  if (result.status === "intentionally-different") {
+    return `${result.lineDiff ?? ""}  (expected - dogfooding vs pj-repo)`;
+  }
+  return STATUS_SUFFIXES[result.status] ?? "";
+}
+function getPathDisplay(result) {
+  const runaPath = result.runaPath ?? "(none)";
+  const templatePath = result.templatePath ?? "(none)";
+  if (result.runaPath && result.templatePath && result.runaPath !== result.templatePath) {
+    return `${runaPath} \u2192 ${templatePath.split("/").pop()}`;
+  }
+  return runaPath !== "(none)" ? runaPath : templatePath;
+}
+function printDiffOutput(logger, diffOutput) {
+  logger.info("");
+  for (const line of diffOutput.split("\n")) {
+    if (line.startsWith("+") && !line.startsWith("+++")) {
+      logger.success(`    ${line}`);
+    } else if (line.startsWith("-") && !line.startsWith("---")) {
+      logger.error(`    ${line}`);
+    } else {
+      logger.info(`    ${line}`);
+    }
+  }
+  logger.info("");
+}
+function printResult(logger, result, verbose) {
+  const icon = STATUS_ICONS[result.status] ?? "\u2753";
+  const pathDisplay = getPathDisplay(result);
+  const suffix = getStatusSuffix(result);
+  const statusLine = suffix ? `  ${icon} ${pathDisplay}  ${suffix}` : `  ${icon} ${pathDisplay}`;
+  if (verbose || result.status !== "identical") {
+    logger.info(statusLine);
+  }
+  if (result.diffOutput) {
+    printDiffOutput(logger, result.diffOutput);
+  }
+}
+function printCategoryReport(logger, category, verbose) {
+  logger.info("");
+  logger.info(`\u2501\u2501\u2501 ${category.displayName} \u2501\u2501\u2501`);
+  for (const result of category.results) {
+    printResult(logger, result, verbose);
+  }
+}
+function printSummary(logger, summary, _durationMs) {
+  const needsAction = summary.diff + summary.runaOnly + summary.templateOnly;
+  logger.info("");
+  logger.info("\u2501\u2501\u2501 Summary (code files only) \u2501\u2501\u2501");
+  logger.info(
+    `  Total: ${summary.total} | In sync: ${summary.identical} | Needs action: ${needsAction}`
+  );
+  if (needsAction === 0) {
+    logger.success("  \u2705 Template is up to date!");
+  } else {
+    logger.warn(`  \u26A0\uFE0F ${needsAction} file(s) need attention`);
+  }
+}
+function printActionGroup(logger, actions, header, isWarning, formatter) {
+  if (actions.length === 0) return;
+  logger.info("");
+  if (isWarning) {
+    logger.warn(header);
+  } else {
+    logger.info(header);
+  }
+  for (const action of actions) {
+    for (const line of formatter(action)) {
+      logger.info(line);
+    }
+  }
+}
+function printActionsNeeded(logger, actions) {
+  if (actions.length === 0) {
+    logger.info("");
+    logger.success("\u2705 All code files are in sync! No action needed.");
+    return;
+  }
+  const updateTemplate = actions.filter((a) => a.ahead === "runa");
+  const checkRuna = actions.filter((a) => a.ahead === "template");
+  const manualMerge = actions.filter((a) => a.ahead === "diverged");
+  const missingInTemplate = actions.filter((a) => a.status === "runa-only");
+  const missingInRuna = actions.filter((a) => a.status === "template-only");
+  logger.info("");
+  logger.info("\u2501\u2501\u2501 Actions Required \u2501\u2501\u2501");
+  printActionGroup(
+    logger,
+    updateTemplate,
+    "\u{1F4E4} UPDATE TEMPLATE (runa-repo has newer code):",
+    false,
+    (action) => {
+      const templatePath = action.targetPath ?? action.path.replace(/^\.claude\//, ".claude/sdk/");
+      return [`   cp ${action.path} packages/runa-templates/templates/${templatePath}`];
+    }
+  );
+  printActionGroup(
+    logger,
+    checkRuna,
+    "\u26A0\uFE0F CHECK RUNA-REPO (template is ahead - unusual):",
+    true,
+    (action) => [
+      `   ${action.path}`,
+      `   \u2192 Template was updated but runa-repo wasn't. Intentional?`
+    ]
+  );
+  printActionGroup(
+    logger,
+    manualMerge,
+    "\u{1F500} MANUAL MERGE NEEDED (both sides changed):",
+    true,
+    (action) => [`   ${action.path}`, "   \u2192 Run: runa template-check --diff to see differences"]
+  );
+  printActionGroup(
+    logger,
+    missingInTemplate,
+    "\u2795 ADD TO TEMPLATE (or mark as runa-only in normalizer.ts):",
+    false,
+    (action) => [`   ${action.path}`]
+  );
+  printActionGroup(
+    logger,
+    missingInRuna,
+    "\u2753 MISSING IN RUNA-REPO (template has code that runa-repo doesn't):",
+    true,
+    (action) => [`   ${action.path}`]
+  );
+}
+function groupResultsByCategory(results) {
+  const categoryMap = /* @__PURE__ */ new Map();
+  for (const result of results) {
+    const existing = categoryMap.get(result.category) ?? [];
+    existing.push(result);
+    categoryMap.set(result.category, existing);
+  }
+  const byCategory = [];
+  for (const [category, categoryResults] of categoryMap) {
+    byCategory.push({
+      category,
+      displayName: CATEGORY_DISPLAY_NAMES2[category] ?? category,
+      results: categoryResults,
+      // Count identical, renamed, and intentionally-different as "in sync"
+      identical: categoryResults.filter(
+        (r) => r.status === "identical" || r.status === "renamed" || r.status === "intentionally-different"
+      ).length,
+      diff: categoryResults.filter((r) => r.status === "diff").length,
+      runaOnly: categoryResults.filter((r) => r.status === "runa-only").length,
+      templateOnly: categoryResults.filter((r) => r.status === "template-only").length,
+      expectedOnly: categoryResults.filter(
+        (r) => r.status === "expected-runa-only" || r.status === "expected-template-only"
+      ).length
+    });
+  }
+  return byCategory;
+}
+function collectActionsNeeded2(results) {
+  return results.filter((r) => r.status === "diff" || r.status === "runa-only" || r.status === "template-only").map((r) => ({
+    path: r.runaPath ?? r.templatePath ?? "",
+    targetPath: r.runaPath && r.templatePath ? r.templatePath : null,
+    status: r.status,
+    ahead: r.ahead ?? null,
+    lineDiff: r.lineDiff ?? null,
+    diffOutput: r.diffOutput
+  }));
+}
+function generateReportOutput(output, isJsonMode) {
+  const { calculateSummary: calculateSummary2 } = (init_types(), __toCommonJS(types_exports));
+  const summary = calculateSummary2(output.results);
+  const byCategory = groupResultsByCategory(output.results);
+  const actionsNeeded = collectActionsNeeded2(output.results);
+  return {
+    byCategory,
+    summary,
+    actionsNeeded,
+    jsonOutput: isJsonMode,
+    jsonString: isJsonMode ? JSON.stringify(
+      { success: output.success, summary, results: output.results, actionsNeeded },
+      null,
+      2
+    ) : void 0
+  };
+}
+function validateRunaRepo(repoRoot) {
+  const { existsSync: existsSync2 } = __require("fs");
+  const { join: join3 } = __require("path");
+  const templateDir = join3(repoRoot, "packages/runa-templates/templates");
+  if (!existsSync2(templateDir)) {
+    throw new CLIError("template-check is a runa-repo only command", "NOT_RUNA_REPO", [
+      "This command compares runa-repo with pj-repo templates",
+      "It should only be run in the runa repository",
+      `Expected: ${templateDir}`
+    ]);
+  }
+}
+async function runTemplateCheckMachine(input, logger) {
+  const repoRoot = input.targetDir ?? findRepoRoot(process.cwd());
+  validateRunaRepo(repoRoot);
+  return new Promise((resolve, reject) => {
+    const actor = createActor(syncCheckMachine, {
+      input: { input, repoRoot }
+    });
+    let previousState = "";
+    const isJsonMode = getOutputFormatFromEnv() === "json";
+    const isQuietMode = input.quiet ?? false;
+    actor.subscribe((snapshot) => {
+      const currentState = getStateName(snapshot);
+      if (currentState !== previousState) {
+        handleStateChange(snapshot, previousState, logger, isJsonMode, isQuietMode);
+        previousState = currentState;
+      }
+      if (isComplete(snapshot)) {
+        const output = snapshot.output;
+        if (output) {
+          const reportOutput = generateReportOutput(output, isJsonMode);
+          resolve({ output, reportOutput });
+        }
+      }
+    });
+    actor.subscribe({
+      error: (error) => {
+        reject(error);
+        actor.stop();
+      }
+    });
+    actor.start();
+    actor.send({ type: "START" });
+  });
+}
+function printReportOutput(logger, reportOutput, durationMs, options) {
+  if (!options.quiet) {
+    for (const category of reportOutput.byCategory) {
+      printCategoryReport(logger, category, options.verbose);
+    }
+  }
+  printSummary(logger, reportOutput.summary);
+  printActionsNeeded(logger, reportOutput.actionsNeeded);
+}
+function wrapError(error) {
+  if (error instanceof CLIError) {
+    return error;
+  }
+  return new CLIError(
+    error instanceof Error ? error.message : String(error),
+    "TEMPLATE_CHECK_ERROR",
+    ["Check file paths and permissions"],
+    error instanceof Error ? error : void 0
+  );
+}
+async function runTemplateCheckAction(options) {
+  const logger = createCLILogger("template-check");
+  try {
+    const { output, reportOutput } = await runTemplateCheckMachine(options, logger);
+    const isJsonMode = getOutputFormatFromEnv() === "json";
+    if (isJsonMode && reportOutput?.jsonString) {
+      console.log(reportOutput.jsonString);
+      process.exit(output.exitCode);
+      return;
+    }
+    if (reportOutput) {
+      printReportOutput(logger, reportOutput, output.durationMs, options);
+    }
+    if (output.error) {
+      throw new CLIError(output.error, "SYNC_CHECK_ERROR");
+    }
+    process.exit(output.exitCode);
+  } catch (error) {
+    throw wrapError(error);
+  }
+}
+var templateCheckCommand = new Command("template-check").description(
+  "Compare runa-repo with SDK templates (runa-repo only)\n\n  Exit codes:\n    0 = All files in sync\n    1 = Differences detected (action needed)\n    2 = Error occurred"
+).option("--verbose", "Show all files including identical ones").option("--diff", "Show unified diff for differences").option("--category <name>", "Filter by category (rules, agents, skills, etc.)").option("--json", "Output as JSON (for CI integration)").option("--quiet", "Only show summary and actions (for pre-commit hooks)").option("--target-dir <path>", "Target directory (defaults to repo root)").action(async (options) => {
+  const input = {
+    verbose: options.verbose ?? false,
+    diff: options.diff ?? false,
+    category: options.category,
+    json: options.json ?? false,
+    quiet: options.quiet ?? false,
+    targetDir: options.targetDir
+  };
+  await runTemplateCheckAction(input);
+});
+
+export { templateCheckCommand };