@mcptoolshop/style-dataset-lab 1.2.1 → 2.1.0

package/scripts/painterly.js

@@ -10,18 +10,17 @@
  * Usage:
  *   node scripts/painterly.js [--source outputs/approved] [--limit 100] [--offset 0]
  *   node scripts/painterly.js --dry-run
+ *   sdlab painterly --project star-freight --limit 50
  *
  * Output: outputs/painterly/<original_filename>
  */
 
-import { readFile, writeFile, mkdir, readdir, copyFile, stat } from "node:fs/promises";
-import { join, basename, extname } from "node:path";
+import { writeFile, mkdir, readdir } from "node:fs/promises";
+import { join } from "node:path";
 import { existsSync } from "node:fs";
-
-const COMFY_URL = process.env.COMFY_URL || "http://127.0.0.1:8188";
-const REPO_ROOT = new URL("..", import.meta.url).pathname.replace(/^\/([A-Z]:)/, "$1");
-const GAME = process.argv.find((a, i) => process.argv[i - 1] === '--game') || 'star-freight';
-const GAME_ROOT = join(REPO_ROOT, 'games', GAME);
+import { getProjectName } from "../lib/args.js";
+import { REPO_ROOT } from "../lib/paths.js";
+import { comfyHealth, submitAndWait, downloadImage, uploadImage } from "../lib/comfyui.js";
 
 // ── Config ──
 
@@ -51,20 +50,10 @@ const DEFAULTS = {
   seed: 42,            // Fixed seed for reproducibility across batch
 };
 
-// ── ComfyUI helpers ──
-
-async function comfyHealth() {
-  try {
-    const res = await fetch(`${COMFY_URL}/system_stats`);
-    return res.ok;
-  } catch { return false; }
-}
-
 function buildImg2ImgWorkflow(imagePath, seed) {
   const nodes = {};
   let nextId = 1;
 
-  // Checkpoint loader
   const ckptId = String(nextId++);
   nodes[ckptId] = {
     class_type: "CheckpointLoaderSimple",
@@ -74,7 +63,6 @@ function buildImg2ImgWorkflow(imagePath, seed) {
   let modelOut = [ckptId, 0];
   let clipOut = [ckptId, 1];
 
-  // LoRA — ClassipeintXL at reduced weight for style shift
   const loraId = String(nextId++);
   nodes[loraId] = {
     class_type: "LoraLoader",
@@ -89,14 +77,12 @@ function buildImg2ImgWorkflow(imagePath, seed) {
   modelOut = [loraId, 0];
   clipOut = [loraId, 1];
 
-  // Load source image
   const loadImgId = String(nextId++);
   nodes[loadImgId] = {
     class_type: "LoadImage",
     inputs: { image: imagePath },
   };
 
-  // VAE Encode — source image to latent
   const vaeEncId = String(nextId++);
   nodes[vaeEncId] = {
     class_type: "VAEEncode",
@@ -106,21 +92,18 @@ function buildImg2ImgWorkflow(imagePath, seed) {
     },
   };
 
-  // CLIP Text Encode — positive (painterly style)
   const posId = String(nextId++);
   nodes[posId] = {
     class_type: "CLIPTextEncode",
     inputs: { text: PAINTERLY_PROMPT, clip: clipOut },
   };
 
-  // CLIP Text Encode — negative
   const negId = String(nextId++);
   nodes[negId] = {
     class_type: "CLIPTextEncode",
     inputs: { text: PAINTERLY_NEGATIVE, clip: clipOut },
   };
 
-  // KSampler — img2img with low denoise
   const samplerId = String(nextId++);
   nodes[samplerId] = {
     class_type: "KSampler",
@@ -138,7 +121,6 @@ function buildImg2ImgWorkflow(imagePath, seed) {
     },
   };
 
-  // VAE Decode
   const vaeDecId = String(nextId++);
   nodes[vaeDecId] = {
     class_type: "VAEDecode",
@@ -148,7 +130,6 @@ function buildImg2ImgWorkflow(imagePath, seed) {
     },
   };
 
-  // Save Image
   const saveId = String(nextId++);
   nodes[saveId] = {
     class_type: "SaveImage",
@@ -161,84 +142,22 @@ function buildImg2ImgWorkflow(imagePath, seed) {
   return { nodes, saveNodeId: saveId };
 }
 
-const MAX_POLL_MS = 600_000; // 10 minutes
+export async function run(argv = process.argv.slice(2)) {
+  const projectName = getProjectName(argv);
+  const GAME_ROOT = join(REPO_ROOT, 'projects', projectName);
+  const COMFY_URL = process.env.COMFY_URL || "http://127.0.0.1:8188";
 
-async function submitAndWait(workflow) {
-  const clientId = `sdl-paint-${Date.now()}`;
-  const res = await fetch(`${COMFY_URL}/prompt`, {
-    method: "POST",
-    headers: { "Content-Type": "application/json" },
-    body: JSON.stringify({ prompt: workflow, client_id: clientId }),
-  });
-
-  if (!res.ok) {
-    const text = await res.text();
-    throw new Error(`ComfyUI submit failed: ${res.status} ${text}`);
-  }
-
-  const { prompt_id: promptId } = await res.json();
-
-  const start = Date.now();
-  while (true) {
-    if (Date.now() - start > MAX_POLL_MS) throw new Error(`ComfyUI poll timeout after ${MAX_POLL_MS/1000}s for prompt ${promptId}`);
-    await new Promise((r) => setTimeout(r, 1000));
-    const histRes = await fetch(`${COMFY_URL}/history/${promptId}`);
-    if (!histRes.ok) continue;
-    const history = await histRes.json();
-    const entry = history[promptId];
-    if (!entry) continue;
-    if (entry.status?.completed) return entry;
-    if (entry.status?.status_str === "error") {
-      throw new Error(`ComfyUI generation failed: ${JSON.stringify(entry.status)}`);
-    }
-  }
-}
-
-async function downloadImage(filename, subfolder, type = "output") {
-  const url = `${COMFY_URL}/view?filename=${encodeURIComponent(filename)}&subfolder=${encodeURIComponent(subfolder || "")}&type=${type}`;
-  const res = await fetch(url);
-  if (!res.ok) throw new Error(`Download failed: ${res.status}`);
-  return Buffer.from(await res.arrayBuffer());
-}
-
-/**
- * Upload an image to ComfyUI's input folder so LoadImage can find it.
- */
-async function uploadImage(filePath, filename) {
-  const data = await readFile(filePath);
-  const formData = new FormData();
-  formData.append("image", new Blob([data], { type: "image/png" }), filename);
-  formData.append("overwrite", "true");
-
-  const res = await fetch(`${COMFY_URL}/upload/image`, {
-    method: "POST",
-    body: formData,
-  });
-
-  if (!res.ok) {
-    const text = await res.text();
-    throw new Error(`Upload failed: ${res.status} ${text}`);
-  }
-
-  const result = await res.json();
-  return result.name; // The name ComfyUI assigned to the uploaded image
-}
-
-// ── Main ──
-
-async function main() {
-  const args = process.argv.slice(2);
-  const dryRun = args.includes("--dry-run");
+  const dryRun = argv.includes("--dry-run");
 
   // Parse args
   let sourceDir = "outputs/approved";
   let limit = 100;
   let offset = 0;
 
-  for (let i = 0; i < args.length; i++) {
-    if (args[i] === "--source" && args[i + 1]) sourceDir = args[++i];
-    if (args[i] === "--limit" && args[i + 1]) limit = parseInt(args[++i]);
-    if (args[i] === "--offset" && args[i + 1]) offset = parseInt(args[++i]);
+  for (let i = 0; i < argv.length; i++) {
+    if (argv[i] === "--source" && argv[i + 1]) sourceDir = argv[++i];
+    if (argv[i] === "--limit" && argv[i + 1]) limit = parseInt(argv[++i]);
+    if (argv[i] === "--offset" && argv[i + 1]) offset = parseInt(argv[++i]);
   }
 
   const fullSourceDir = join(GAME_ROOT, sourceDir);
@@ -274,10 +193,9 @@ async function main() {
   }
 
   if (!dryRun) {
-    const online = await comfyHealth();
+    const online = await comfyHealth(COMFY_URL);
     if (!online) {
-      console.error("\x1b[31mError:\x1b[0m ComfyUI not reachable at " + COMFY_URL);
-      process.exit(1);
+      throw new Error("ComfyUI not reachable at " + COMFY_URL);
     }
     console.log("\x1b[32m✓\x1b[0m ComfyUI online");
   }
@@ -298,11 +216,11 @@ async function main() {
       const startMs = Date.now();
 
       // Upload source image to ComfyUI
-      const uploadedName = await uploadImage(srcPath, file);
+      const uploadedName = await uploadImage(srcPath, file, COMFY_URL);
 
       // Build and submit img2img workflow
       const { nodes } = buildImg2ImgWorkflow(uploadedName, DEFAULTS.seed);
-      const result = await submitAndWait(nodes);
+      const result = await submitAndWait(nodes, COMFY_URL, { clientPrefix: 'sdl-paint' });
       const elapsed = Date.now() - startMs;
 
       // Find output image
@@ -325,7 +243,7 @@ async function main() {
       }
 
       // Download and save with original filename
-      const imgData = await downloadImage(imageFile, imageSubfolder);
+      const imgData = await downloadImage(imageFile, imageSubfolder, COMFY_URL);
       await writeFile(join(outDir, file), imgData);
 
       const kb = Math.round(imgData.length / 1024);
@@ -343,7 +261,10 @@ async function main() {
   if (dryRun) console.log("  (dry run — no images processed)");
 }
 
-main().catch((err) => {
-  console.error(err);
-  process.exit(1);
-});
+// Direct execution guard
+if (process.argv[1] && (process.argv[1].endsWith('painterly.js') || process.argv[1].endsWith('painterly'))) {
+  run().catch((err) => {
+    console.error(err.message || err);
+    process.exit(1);
+  });
+}

package/scripts/snapshot.js

@@ -0,0 +1,132 @@
+#!/usr/bin/env node
+
+/**
+ * snapshot.js — Create, list, show, and diff dataset snapshots.
+ *
+ * Usage:
+ *   sdlab snapshot create [--profile <name>] [--project <name>]
+ *   sdlab snapshot list [--project <name>]
+ *   sdlab snapshot show <snapshot-id> [--project <name>]
+ *   sdlab snapshot diff <id-a> <id-b> [--project <name>]
+ */
+
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { existsSync } from 'node:fs';
+import { getProjectName } from '../lib/args.js';
+import { REPO_ROOT } from '../lib/paths.js';
+import { loadSelectionProfile } from '../lib/config.js';
+import { createSnapshot, loadSnapshot, listSnapshots, diffSnapshots } from '../lib/snapshot.js';
+import { evaluateEligibility } from '../lib/eligibility.js';
+import { categorizeExclusions } from '../lib/eligibility.js';
+
+export async function run(argv = process.argv.slice(2)) {
+  const projectName = getProjectName(argv);
+  const projectRoot = join(REPO_ROOT, 'projects', projectName);
+  const subcommand = argv.find(a => !a.startsWith('--')) || 'list';
+
+  // Strip subcommand from argv for flag parsing
+  const args = argv.filter(a => a !== subcommand);
+
+  if (subcommand === 'create') {
+    const profileIdx = args.indexOf('--profile');
+    const profileId = profileIdx >= 0 ? args[profileIdx + 1] : null;
+    const profile = loadSelectionProfile(projectRoot, profileId);
+
+    console.log(`\x1b[1msdlab snapshot create\x1b[0m — ${projectName}`);
+    console.log(`  Profile: ${profileId || 'training-default (built-in)'}`);
+    console.log('');
+
+    const result = await createSnapshot(projectRoot, profile);
+
+    console.log(`  \x1b[32m✓\x1b[0m Snapshot: ${result.snapshotId}`);
+    console.log(`  Included: ${result.included}`);
+    console.log(`  Excluded: ${result.excluded}`);
+
+    // Read and display summary
+    const summary = JSON.parse(
+      await readFile(join(projectRoot, 'snapshots', result.snapshotId, 'summary.json'), 'utf-8')
+    );
+    console.log('\n  Lane distribution:');
+    for (const [lane, count] of Object.entries(summary.lane_distribution).sort((a, b) => b[1] - a[1])) {
+      console.log(`    ${lane}: ${count}`);
+    }
+    console.log('\n  Faction distribution:');
+    for (const [f, c] of Object.entries(summary.faction_distribution).sort((a, b) => b[1] - a[1])) {
+      console.log(`    ${f}: ${c}`);
+    }
+
+    // Read and categorize exclusions
+    const excludedRaw = await readFile(
+      join(projectRoot, 'snapshots', result.snapshotId, 'excluded.jsonl'), 'utf-8'
+    );
+    const excluded = excludedRaw.trim().split('\n').filter(Boolean).map(l => JSON.parse(l));
+    const categories = categorizeExclusions(excluded);
+    console.log('\n  Exclusion reasons:');
+    for (const [cat, count] of Object.entries(categories)) {
+      if (count > 0) console.log(`    ${cat}: ${count}`);
+    }
+
+  } else if (subcommand === 'list') {
+    const snapshots = await listSnapshots(projectRoot);
+    if (snapshots.length === 0) {
+      console.log('No snapshots found. Run: sdlab snapshot create');
+      return;
+    }
+    console.log(`\x1b[1mSnapshots\x1b[0m — ${projectName}\n`);
+    for (const s of snapshots) {
+      console.log(`  ${s.id}  included=${s.included}  excluded=${s.excluded}  fp=${s.fingerprint}  ${s.created_at}`);
+    }
+
+  } else if (subcommand === 'show') {
+    const snapshotId = args.find(a => a.startsWith('snap-'));
+    if (!snapshotId) throw new Error('Usage: sdlab snapshot show <snapshot-id>');
+
+    const manifest = await loadSnapshot(projectRoot, snapshotId);
+    console.log(`\x1b[1mSnapshot\x1b[0m — ${snapshotId}\n`);
+    console.log(`  Created: ${manifest.created_at}`);
+    console.log(`  Project: ${manifest.project_name}`);
+    console.log(`  Frozen:  ${manifest.frozen}`);
+    console.log(`  Records: ${manifest.counts.total_records}`);
+    console.log(`  Included: ${manifest.counts.included}`);
+    console.log(`  Excluded: ${manifest.counts.excluded}`);
+    console.log(`  Config fingerprint: ${manifest.config_fingerprint}`);
+    console.log('');
+    console.log('  Selection profile:');
+    for (const [k, v] of Object.entries(manifest.selection_profile)) {
+      console.log(`    ${k}: ${JSON.stringify(v)}`);
+    }
+
+  } else if (subcommand === 'diff') {
+    const snapIds = args.filter(a => a.startsWith('snap-'));
+    if (snapIds.length < 2) throw new Error('Usage: sdlab snapshot diff <id-a> <id-b>');
+
+    const diff = await diffSnapshots(projectRoot, snapIds[0], snapIds[1]);
+    console.log(`\x1b[1mSnapshot diff\x1b[0m — ${snapIds[0]} vs ${snapIds[1]}\n`);
+    console.log(`  ${snapIds[0]}: ${diff.countA} records`);
+    console.log(`  ${snapIds[1]}: ${diff.countB} records`);
+    console.log(`  Shared: ${diff.shared.length}`);
+    console.log(`  Added in ${snapIds[1]}: ${diff.added.length}`);
+    console.log(`  Removed from ${snapIds[0]}: ${diff.removed.length}`);
+
+    if (diff.added.length > 0 && diff.added.length <= 20) {
+      console.log('\n  Added:');
+      for (const id of diff.added) console.log(`    + ${id}`);
+    }
+    if (diff.removed.length > 0 && diff.removed.length <= 20) {
+      console.log('\n  Removed:');
+      for (const id of diff.removed) console.log(`    - ${id}`);
+    }
+
+  } else {
+    throw new Error(`Unknown subcommand: ${subcommand}. Use: create, list, show, diff`);
+  }
+}
+
+// Direct execution guard
+if (process.argv[1] && (process.argv[1].endsWith('snapshot.js') || process.argv[1].endsWith('snapshot'))) {
+  run().catch((err) => {
+    console.error(err.message || err);
+    process.exit(1);
+  });
+}

package/scripts/split.js

@@ -0,0 +1,154 @@
+#!/usr/bin/env node
+
+/**
+ * split.js — Build, show, and audit dataset splits.
+ *
+ * Usage:
+ *   sdlab split build [--snapshot <id>] [--profile <name>] [--project <name>]
+ *   sdlab split list [--project <name>]
+ *   sdlab split show <split-id> [--project <name>]
+ *   sdlab split audit <split-id> [--project <name>]
+ */
+
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { getProjectName } from '../lib/args.js';
+import { REPO_ROOT } from '../lib/paths.js';
+import { loadSplitProfile } from '../lib/config.js';
+import { listSnapshots } from '../lib/snapshot.js';
+import { createSplit, loadSplit, loadSplitAudit, listSplits } from '../lib/split.js';
+
+export async function run(argv = process.argv.slice(2)) {
+  const projectName = getProjectName(argv);
+  const projectRoot = join(REPO_ROOT, 'projects', projectName);
+  const subcommand = argv.find(a => !a.startsWith('--')) || 'list';
+  const args = argv.filter(a => a !== subcommand);
+
+  if (subcommand === 'build') {
+    // Find snapshot ID
+    let snapshotId;
+    const snapIdx = args.indexOf('--snapshot');
+    if (snapIdx >= 0) {
+      snapshotId = args[snapIdx + 1];
+    } else {
+      // Use latest snapshot
+      const snapshots = await listSnapshots(projectRoot);
+      if (snapshots.length === 0) {
+        throw new Error('No snapshots found. Run: sdlab snapshot create');
+      }
+      snapshotId = snapshots[snapshots.length - 1].id;
+    }
+
+    const profileIdx = args.indexOf('--profile');
+    const profileId = profileIdx >= 0 ? args[profileIdx + 1] : null;
+    const profile = loadSplitProfile(projectRoot, profileId);
+
+    console.log(`\x1b[1msdlab split build\x1b[0m — ${projectName}`);
+    console.log(`  Snapshot: ${snapshotId}`);
+    console.log(`  Profile:  ${profileId || 'balanced-default (built-in)'}`);
+    console.log(`  Strategy: ${profile.strategy}`);
+    console.log(`  Ratios:   ${profile.train_ratio}/${profile.val_ratio}/${profile.test_ratio}`);
+    console.log(`  Seed:     ${profile.seed}`);
+    console.log('');
+
+    const result = await createSplit(projectRoot, snapshotId, profile);
+
+    console.log(`  \x1b[32m✓\x1b[0m Split: ${result.splitId}`);
+    console.log(`  Train: ${result.train}`);
+    console.log(`  Val:   ${result.val}`);
+    console.log(`  Test:  ${result.test}`);
+
+    // Show audit summary
+    const audit = await loadSplitAudit(projectRoot, result.splitId);
+    console.log('');
+    if (audit.leakage_check.passed) {
+      console.log(`  \x1b[32m✓\x1b[0m No subject leakage detected`);
+    } else {
+      console.log(`  \x1b[31m✗\x1b[0m Subject leakage detected:`);
+      for (const issue of audit.leakage_check.issues) {
+        console.log(`    family="${issue.family}" (${issue.record_count} records) → ${issue.leaked_to.join(', ')}`);
+      }
+    }
+
+    console.log(`  Families: ${audit.family_count} (train=${audit.families_per_split.train}, val=${audit.families_per_split.val}, test=${audit.families_per_split.test})`);
+
+  } else if (subcommand === 'list') {
+    const splits = await listSplits(projectRoot);
+    if (splits.length === 0) {
+      console.log('No splits found. Run: sdlab split build');
+      return;
+    }
+    console.log(`\x1b[1mSplits\x1b[0m — ${projectName}\n`);
+    for (const s of splits) {
+      console.log(`  ${s.id}  snap=${s.snapshot_id}  train=${s.train} val=${s.val} test=${s.test}  families=${s.families}  ${s.created_at}`);
+    }
+
+  } else if (subcommand === 'show') {
+    const splitId = args.find(a => a.startsWith('split-'));
+    if (!splitId) throw new Error('Usage: sdlab split show <split-id>');
+
+    const manifest = await loadSplit(projectRoot, splitId);
+    console.log(`\x1b[1mSplit\x1b[0m — ${splitId}\n`);
+    console.log(`  Created:  ${manifest.created_at}`);
+    console.log(`  Snapshot: ${manifest.snapshot_id}`);
+    console.log(`  Records:  ${manifest.counts.total_records}`);
+    console.log(`  Families: ${manifest.counts.total_families}`);
+    console.log(`  Train:    ${manifest.counts.train}`);
+    console.log(`  Val:      ${manifest.counts.val}`);
+    console.log(`  Test:     ${manifest.counts.test}`);
+    console.log('');
+    console.log('  Profile:');
+    for (const [k, v] of Object.entries(manifest.profile)) {
+      console.log(`    ${k}: ${JSON.stringify(v)}`);
+    }
+    if (manifest.warnings.length > 0) {
+      console.log('');
+      console.log('  Warnings:');
+      for (const w of manifest.warnings) {
+        console.log(`    ⚠ ${w}`);
+      }
+    }
+
+  } else if (subcommand === 'audit') {
+    const splitId = args.find(a => a.startsWith('split-'));
+    if (!splitId) throw new Error('Usage: sdlab split audit <split-id>');
+
+    const audit = await loadSplitAudit(projectRoot, splitId);
+    console.log(`\x1b[1mSplit audit\x1b[0m — ${splitId}\n`);
+
+    // Leakage check
+    if (audit.leakage_check.passed) {
+      console.log(`  \x1b[32m✓\x1b[0m Leakage check: PASSED`);
+    } else {
+      console.log(`  \x1b[31m✗\x1b[0m Leakage check: FAILED`);
+      for (const issue of audit.leakage_check.issues) {
+        console.log(`    family="${issue.family}" (${issue.record_count} records) leaked to: ${issue.leaked_to.join(', ')}`);
+      }
+    }
+
+    // Family distribution
+    console.log(`\n  Families: ${audit.family_count}`);
+    console.log(`    Train: ${audit.families_per_split.train}`);
+    console.log(`    Val:   ${audit.families_per_split.val}`);
+    console.log(`    Test:  ${audit.families_per_split.test}`);
+
+    // Lane balance
+    console.log('\n  Lane balance:');
+    console.log(`    ${'Lane'.padEnd(20)} ${'Total'.padStart(6)} ${'Train%'.padStart(8)} ${'Val%'.padStart(8)} ${'Test%'.padStart(8)}`);
+    console.log(`    ${'─'.repeat(52)}`);
+    for (const [lane, b] of Object.entries(audit.lane_balance).sort((a, b) => b[1].total - a[1].total)) {
+      console.log(`    ${lane.padEnd(20)} ${String(b.total).padStart(6)} ${String(b.train_pct + '%').padStart(8)} ${String(b.val_pct + '%').padStart(8)} ${String(b.test_pct + '%').padStart(8)}`);
+    }
+
+  } else {
+    throw new Error(`Unknown subcommand: ${subcommand}. Use: build, list, show, audit`);
+  }
+}
+
+// Direct execution guard
+if (process.argv[1] && (process.argv[1].endsWith('split.js') || process.argv[1].endsWith('split'))) {
+  run().catch((err) => {
+    console.error(err.message || err);
+    process.exit(1);
+  });
+}

package/templates/domains/architecture/constitution.json

@@ -0,0 +1,97 @@
+{
+  "version": "1.0.0",
+  "rules": [
+    {
+      "id": "STR-001",
+      "category": "structure",
+      "desc": "Structural plausibility — buildings look like they could stand",
+      "dims": ["structural_plausibility"],
+      "faction_specific": false,
+      "rationale_pass": "Structure reads as plausible — load paths and massing are believable (${scorePct}%)",
+      "rationale_fail": "Structure implausible — walls, spans, or cantilevers defy credible engineering (${scorePct}%)"
+    },
+    {
+      "id": "MAT-001",
+      "category": "material",
+      "desc": "Material consistency — stone reads as stone, wood as wood, metal as metal",
+      "dims": ["material_consistency"],
+      "faction_specific": false,
+      "rationale_pass": "Materials read correctly — surfaces have appropriate weight, texture, and joinery (${scorePct}%)",
+      "rationale_fail": "Material reads wrong — surface lacks expected weight, grain, or construction logic (${scorePct}%)"
+    },
+    {
+      "id": "PER-001",
+      "category": "perspective",
+      "desc": "Perspective accuracy — no impossible geometry or broken vanishing points",
+      "dims": ["perspective_accuracy"],
+      "faction_specific": false,
+      "rationale_pass": "Perspective is accurate — vanishing points consistent, no spatial contradictions (${scorePct}%)",
+      "rationale_fail": "Perspective broken — impossible geometry, misaligned vanishing points, or spatial contradictions (${scorePct}%)"
+    },
+    {
+      "id": "LGT-001",
+      "category": "lighting",
+      "desc": "Lighting and mood — atmosphere serves narrative intent",
+      "dims": ["lighting_mood"],
+      "faction_specific": false,
+      "rationale_pass": "Lighting carries mood — shadow, bounce, and atmosphere serve the narrative intent (${scorePct}%)",
+      "rationale_fail": "Lighting flat or contradictory — no mood, multiple shadow sources, or atmosphere works against intent (${scorePct}%)"
+    },
+    {
+      "id": "SCL-001",
+      "category": "scale",
+      "desc": "Scale consistency — human-scale reference readable",
+      "dims": ["scale_consistency"],
+      "faction_specific": false,
+      "rationale_pass": "Scale reads correctly — doors, windows, and elements imply consistent human proportion (${scorePct}%)",
+      "rationale_fail": "Scale inconsistent — elements contradict each other or lack human-scale reference (${scorePct}%)"
+    },
+    {
+      "id": "ERA-001",
+      "category": "era",
+      "desc": "Era and tech-level coherence — no anachronisms within the depicted period",
+      "dims": ["era_coherence"],
+      "faction_specific": false,
+      "rationale_pass": "Era coherent — construction methods, ornament, and technology match the depicted period (${scorePct}%)",
+      "rationale_fail": "Anachronism present — elements from incompatible time periods or tech levels mixed (${scorePct}%)"
+    },
+    {
+      "id": "WEA-001",
+      "category": "weathering",
+      "desc": "Weathering and aging appropriate to era, climate, and material",
+      "dims": ["weathering_logic"],
+      "faction_specific": false,
+      "rationale_pass": "Weathering reads correctly — aging pattern matches material, climate, and implied age (${scorePct}%)",
+      "rationale_fail": "Weathering illogical — wear doesn't match material behavior, climate, or timeframe (${scorePct}%)"
+    },
+    {
+      "id": "STY-001",
+      "category": "style",
+      "desc": "Style consistency within the project — rendering and design language unified",
+      "dims": ["style_consistency"],
+      "faction_specific": false,
+      "rationale_pass": "Style consistent — rendering approach and design language match the project standard (${scorePct}%)",
+      "rationale_fail": "Style inconsistent — rendering or design language breaks from project standard (${scorePct}%)"
+    },
+    {
+      "id": "DET-001",
+      "category": "detail",
+      "desc": "Detail density appropriate to distance and scale of view",
+      "dims": ["detail_density"],
+      "faction_specific": false,
+      "lanes": ["structural_detail"],
+      "rationale_pass": "Detail density appropriate — close-ups show construction logic, wide shots stay readable (${scorePct}%)",
+      "rationale_fail": "Detail density wrong — close-up lacks construction detail or wide shot is noisy and unreadable (${scorePct}%)"
+    },
+    {
+      "id": "RUI-001",
+      "category": "ruin",
+      "desc": "Ruin logic — decay pattern follows structural weaknesses and material behavior",
+      "dims": ["ruin_logic"],
+      "faction_specific": false,
+      "lanes": ["ruin"],
+      "rationale_pass": "Ruin logic holds — collapse follows structural weakness, material decay is physically plausible (${scorePct}%)",
+      "rationale_fail": "Ruin logic fails — decay is arbitrary, structure collapses where it shouldn't or survives where it can't (${scorePct}%)"
+    }
+  ]
+}

package/templates/domains/architecture/lanes.json

@@ -0,0 +1,41 @@
+{
+  "default_lane": "exterior",
+  "lanes": [
+    {
+      "id": "exterior",
+      "label": "Building Exterior",
+      "description": "Building facades, elevations, full exterior views, architectural massing",
+      "id_patterns": ["^ext_", "^building_", "^facade_"]
+    },
+    {
+      "id": "interior",
+      "label": "Interior Space",
+      "description": "Rooms, halls, chambers, functional interiors with spatial atmosphere",
+      "id_patterns": ["^int_", "^room_", "^hall_"]
+    },
+    {
+      "id": "streetscape",
+      "label": "Streetscape / Urban",
+      "description": "Street-level views, district overviews, urban fabric and city scenes",
+      "id_patterns": ["^street_", "^district_", "^urban_"]
+    },
+    {
+      "id": "structural_detail",
+      "label": "Structural Detail",
+      "description": "Ornamental elements, material studies, construction details, decorative motifs",
+      "id_patterns": ["^detail_", "^ornament_", "^material_"]
+    },
+    {
+      "id": "ruin",
+      "label": "Ruin / Decay",
+      "description": "Ruined structures, abandoned buildings, post-collapse environments",
+      "id_patterns": ["^ruin_", "^decay_", "^abandoned_"]
+    },
+    {
+      "id": "landscape",
+      "label": "Landscape / Vista",
+      "description": "Wide establishing shots, panoramic views, architecture in landscape context",
+      "id_patterns": ["^landscape_", "^vista_", "^panorama_"]
+    }
+  ]
+}