@mcptoolshop/style-dataset-lab 2.3.0 → 3.0.1

package/scripts/split.js

@@ -10,43 +10,45 @@
  *   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 { parseArgs, getProjectName } from '../lib/args.js';
 import { REPO_ROOT } from '../lib/paths.js';
 import { loadSplitProfile } from '../lib/config.js';
+import { inputError, handleCliError } from '../lib/errors.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 { flags, positionals } = parseArgs(argv, {
+    flags: {
+      project: { type: 'string' },
+      snapshot: { type: 'string' },
+      profile: { type: 'string' },
+      'dry-run': { type: 'boolean', default: false },
+    },
+    deprecated: { game: 'project' },
+  });
+
+  const projectName = flags.project || getProjectName(argv);
   const projectRoot = join(REPO_ROOT, 'projects', projectName);
-  const subcommand = argv.find(a => !a.startsWith('--')) || 'list';
-  const args = argv.filter(a => a !== subcommand);
+  const subcommand = positionals[0] || 'list';
+  const dryRun = flags['dry-run'] || flags.dryRun;
 
   if (subcommand === 'build') {
-    // Find snapshot ID
-    let snapshotId;
-    const snapIdx = args.indexOf('--snapshot');
-    if (snapIdx >= 0) {
-      snapshotId = args[snapIdx + 1];
-    } else {
-      // Use latest snapshot
+    let snapshotId = flags.snapshot;
+    if (!snapshotId) {
       const snapshots = await listSnapshots(projectRoot);
       if (snapshots.length === 0) {
-        throw new Error('No snapshots found. Run: sdlab snapshot create');
+        throw inputError('INPUT_NO_SNAPSHOT', '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);
-    const dryRun = argv.includes('--dry-run');
+    const profile = loadSplitProfile(projectRoot, flags.profile);
 
     console.log(`\x1b[1msdlab split build\x1b[0m — ${projectName}`);
     console.log(`  Snapshot: ${snapshotId}`);
-    console.log(`  Profile:  ${profileId || 'balanced-default (built-in)'}`);
+    console.log(`  Profile:  ${flags.profile || '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}`);
@@ -60,7 +62,6 @@ export async function run(argv = process.argv.slice(2)) {
     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) {
@@ -86,8 +87,8 @@ export async function run(argv = process.argv.slice(2)) {
     }
 
   } else if (subcommand === 'show') {
-    const splitId = args.find(a => a.startsWith('split-'));
-    if (!splitId) throw new Error('Usage: sdlab split show <split-id>');
+    const splitId = positionals[1] || positionals.find(a => a.startsWith('split-'));
+    if (!splitId) throw inputError('INPUT_MISSING_ARGS', 'Usage: sdlab split show <split-id>');
 
     const manifest = await loadSplit(projectRoot, splitId);
     console.log(`\x1b[1mSplit\x1b[0m — ${splitId}\n`);
@@ -112,13 +113,12 @@ export async function run(argv = process.argv.slice(2)) {
     }
 
   } else if (subcommand === 'audit') {
-    const splitId = args.find(a => a.startsWith('split-'));
-    if (!splitId) throw new Error('Usage: sdlab split audit <split-id>');
+    const splitId = positionals[1] || positionals.find(a => a.startsWith('split-'));
+    if (!splitId) throw inputError('INPUT_MISSING_ARGS', '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 {
@@ -128,13 +128,11 @@ export async function run(argv = process.argv.slice(2)) {
       }
     }
 
-    // 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)}`);
@@ -143,14 +141,11 @@ export async function run(argv = process.argv.slice(2)) {
     }
 
   } else {
-    throw new Error(`Unknown subcommand: ${subcommand}. Use: build, list, show, audit`);
+    throw inputError('INPUT_BAD_SUBCOMMAND', `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);
-  });
+  run().catch(handleCliError);
 }

package/scripts/training-manifest.js

@@ -11,8 +11,9 @@
  */
 
 import { join } from 'node:path';
-import { getProjectName } from '../lib/args.js';
+import { parseArgs, getProjectName } from '../lib/args.js';
 import { REPO_ROOT } from '../lib/paths.js';
+import { inputError, handleCliError } from '../lib/errors.js';
 import { listExports } from '../lib/export.js';
 import {
   createTrainingManifest,
@@ -22,30 +23,34 @@ import {
 } from '../lib/training-manifests.js';
 
 export async function run(argv = process.argv.slice(2)) {
-  const projectName = getProjectName(argv);
+  const { flags, positionals } = parseArgs(argv, {
+    flags: {
+      project: { type: 'string' },
+      export: { type: 'string' },
+      profile: { type: 'string' },
+      adapter: { type: 'string' },
+      'base-model': { type: 'string' },
+    },
+    deprecated: { game: 'project' },
+  });
+
+  const projectName = flags.project || getProjectName(argv);
   const projectRoot = join(REPO_ROOT, 'projects', projectName);
-  const subcommand = argv.find(a => !a.startsWith('--') && !a.startsWith('tm-')) || 'list';
-  const args = argv.filter(a => a !== subcommand);
+  const subcommand = positionals.find(a => !a.startsWith('tm-')) || 'list';
 
   if (subcommand === 'create') {
-    // Required: --export and --profile
-    const exportIdx = args.indexOf('--export');
-    if (exportIdx < 0) {
-      // Try latest export
+    let exportId = flags.export;
+    if (!exportId) {
       const exports = await listExports(projectRoot);
-      if (exports.length === 0) throw new Error('No exports found. Run: sdlab export build');
+      if (exports.length === 0) throw inputError('INPUT_NO_EXPORT', 'No exports found. Run: sdlab export build');
+      exportId = exports[exports.length - 1].id;
     }
-    const exportId = exportIdx >= 0 ? args[exportIdx + 1] : (await listExports(projectRoot)).pop().id;
 
-    const profileIdx = args.indexOf('--profile');
-    if (profileIdx < 0) throw new Error('--profile is required. Use: sdlab training-profile list');
-    const profileId = args[profileIdx + 1];
+    if (!flags.profile) throw inputError('INPUT_MISSING_FLAG', '--profile is required. Use: sdlab training-profile list');
+    const profileId = flags.profile;
 
-    const adapterIdx = args.indexOf('--adapter');
-    const adapterTarget = adapterIdx >= 0 ? args[adapterIdx + 1] : undefined;
-
-    const baseModelIdx = args.indexOf('--base-model');
-    const baseModel = baseModelIdx >= 0 ? args[baseModelIdx + 1] : undefined;
+    const adapterTarget = flags.adapter;
+    const baseModel = flags['base-model'] || flags.baseModel;
 
     console.log(`\x1b[1msdlab training-manifest create\x1b[0m — ${projectName}`);
     console.log(`  Export:  ${exportId}`);
@@ -62,8 +67,8 @@ export async function run(argv = process.argv.slice(2)) {
     console.log(`  \x1b[32m✓\x1b[0m Manifest: ${result.manifestId}`);
 
   } else if (subcommand === 'validate') {
-    const manifestId = args.find(a => a.startsWith('tm-'));
-    if (!manifestId) throw new Error('Usage: sdlab training-manifest validate <manifest-id>');
+    const manifestId = positionals.find(a => a.startsWith('tm-'));
+    if (!manifestId) throw inputError('INPUT_MISSING_ARGS', 'Usage: sdlab training-manifest validate <manifest-id>');
 
     console.log(`\x1b[1msdlab training-manifest validate\x1b[0m — ${manifestId}\n`);
     const { valid, issues } = await validateTrainingManifest(projectRoot, manifestId);
@@ -78,8 +83,8 @@ export async function run(argv = process.argv.slice(2)) {
     }
 
   } else if (subcommand === 'show') {
-    const manifestId = args.find(a => a.startsWith('tm-'));
-    if (!manifestId) throw new Error('Usage: sdlab training-manifest show <manifest-id>');
+    const manifestId = positionals.find(a => a.startsWith('tm-'));
+    if (!manifestId) throw inputError('INPUT_MISSING_ARGS', 'Usage: sdlab training-manifest show <manifest-id>');
 
     const manifest = await loadTrainingManifest(projectRoot, manifestId);
     console.log(`\x1b[1mTraining manifest\x1b[0m — ${manifestId}\n`);
@@ -110,10 +115,10 @@ export async function run(argv = process.argv.slice(2)) {
     }
 
   } else {
-    throw new Error(`Unknown subcommand: ${subcommand}. Use: create, validate, show, list`);
+    throw inputError('INPUT_BAD_SUBCOMMAND', `Unknown subcommand: ${subcommand}. Use: create, validate, show, list`);
   }
 }
 
 if (process.argv[1] && (process.argv[1].endsWith('training-manifest.js') || process.argv[1].endsWith('training-manifest'))) {
-  run().catch((err) => { console.error(err.message || err); process.exit(1); });
+  run().catch(handleCliError);
 }

package/scripts/training-package.js

@@ -10,48 +10,52 @@
  */
 
 import { join } from 'node:path';
-import { getProjectName } from '../lib/args.js';
+import { parseArgs, getProjectName } from '../lib/args.js';
 import { REPO_ROOT } from '../lib/paths.js';
+import { inputError, handleCliError } from '../lib/errors.js';
 import { listTrainingManifests } from '../lib/training-manifests.js';
 import { buildTrainingPackage, listTrainingPackages, loadTrainingPackage } from '../lib/training-packages.js';
 
 export async function run(argv = process.argv.slice(2)) {
-  const projectName = getProjectName(argv);
+  const { flags, positionals } = parseArgs(argv, {
+    flags: {
+      project: { type: 'string' },
+      manifest: { type: 'string' },
+      adapter: { type: 'string' },
+      copy: { type: 'boolean', default: false },
+    },
+    deprecated: { game: 'project' },
+  });
+
+  const projectName = flags.project || getProjectName(argv);
   const projectRoot = join(REPO_ROOT, 'projects', projectName);
-  const subcommand = argv.find(a => !a.startsWith('--') && !a.startsWith('tp-') && !a.startsWith('tm-')) || 'list';
-  const args = argv.filter(a => a !== subcommand);
+  const subcommand = positionals.find(a => !a.startsWith('tp-') && !a.startsWith('tm-')) || 'list';
 
   if (subcommand === 'build') {
-    // Find manifest
-    let manifestId;
-    const manifestIdx = args.indexOf('--manifest');
-    if (manifestIdx >= 0) {
-      manifestId = args[manifestIdx + 1];
-    } else {
+    let manifestId = flags.manifest;
+    if (!manifestId) {
       const manifests = await listTrainingManifests(projectRoot);
-      if (manifests.length === 0) throw new Error('No training manifests found. Run: sdlab training-manifest create');
+      if (manifests.length === 0) throw inputError('INPUT_NO_MANIFEST', 'No training manifests found. Run: sdlab training-manifest create');
       manifestId = manifests[manifests.length - 1].id;
     }
 
-    const adapterIdx = args.indexOf('--adapter');
-    const adapterOverride = adapterIdx >= 0 ? args[adapterIdx + 1] : undefined;
-    const copy = args.includes('--copy');
+    const adapterOverride = flags.adapter;
 
     console.log(`\x1b[1msdlab training-package build\x1b[0m — ${projectName}`);
     console.log(`  Manifest: ${manifestId}`);
     if (adapterOverride) console.log(`  Adapter:  ${adapterOverride}`);
-    console.log(`  Images:   ${copy ? 'copy' : 'symlink'}`);
+    console.log(`  Images:   ${flags.copy ? 'copy' : 'symlink'}`);
     console.log('');
 
-    const result = await buildTrainingPackage(projectRoot, manifestId, { copy, adapterOverride });
+    const result = await buildTrainingPackage(projectRoot, manifestId, { copy: flags.copy, adapterOverride });
 
     console.log(`  \x1b[32m✓\x1b[0m Package: ${result.packageId}`);
     console.log(`  Records: ${result.records}`);
     console.log(`  Images:  ${result.images}`);
 
   } else if (subcommand === 'show') {
-    const packageId = args.find(a => a.startsWith('tp-'));
-    if (!packageId) throw new Error('Usage: sdlab training-package show <package-id>');
+    const packageId = positionals.find(a => a.startsWith('tp-'));
+    if (!packageId) throw inputError('INPUT_MISSING_ARGS', 'Usage: sdlab training-package show <package-id>');
 
     const pkg = await loadTrainingPackage(projectRoot, packageId);
     console.log(`\x1b[1mTraining package\x1b[0m — ${packageId}\n`);
@@ -75,10 +79,10 @@ export async function run(argv = process.argv.slice(2)) {
     }
 
   } else {
-    throw new Error(`Unknown subcommand: ${subcommand}. Use: build, show, list`);
+    throw inputError('INPUT_BAD_SUBCOMMAND', `Unknown subcommand: ${subcommand}. Use: build, show, list`);
   }
 }
 
 if (process.argv[1] && (process.argv[1].endsWith('training-package.js') || process.argv[1].endsWith('training-package'))) {
-  run().catch((err) => { console.error(err.message || err); process.exit(1); });
+  run().catch(handleCliError);
 }

package/scripts/training-profile.js

@@ -9,15 +9,20 @@
  */
 
 import { join } from 'node:path';
-import { getProjectName } from '../lib/args.js';
+import { parseArgs, getProjectName } from '../lib/args.js';
 import { REPO_ROOT } from '../lib/paths.js';
+import { inputError, handleCliError } from '../lib/errors.js';
 import { listTrainingProfiles, loadTrainingProfile } from '../lib/training-profiles.js';
 
 export async function run(argv = process.argv.slice(2)) {
-  const projectName = getProjectName(argv);
+  const { flags, positionals } = parseArgs(argv, {
+    flags: { project: { type: 'string' } },
+    deprecated: { game: 'project' },
+  });
+
+  const projectName = flags.project || getProjectName(argv);
   const projectRoot = join(REPO_ROOT, 'projects', projectName);
-  const subcommand = argv.find(a => !a.startsWith('--')) || 'list';
-  const args = argv.filter(a => a !== subcommand);
+  const subcommand = positionals[0] || 'list';
 
   if (subcommand === 'list') {
     const profiles = await listTrainingProfiles(projectRoot);
@@ -31,8 +36,8 @@ export async function run(argv = process.argv.slice(2)) {
     }
 
   } else if (subcommand === 'show') {
-    const profileId = args.find(a => !a.startsWith('--'));
-    if (!profileId) throw new Error('Usage: sdlab training-profile show <profile-id>');
+    const profileId = positionals[1];
+    if (!profileId) throw inputError('INPUT_MISSING_ARGS', 'Usage: sdlab training-profile show <profile-id>');
 
     const profile = await loadTrainingProfile(projectRoot, profileId);
     console.log(`\x1b[1mTraining profile\x1b[0m — ${profileId}\n`);
@@ -54,10 +59,10 @@ export async function run(argv = process.argv.slice(2)) {
     }
 
   } else {
-    throw new Error(`Unknown subcommand: ${subcommand}. Use: list, show`);
+    throw inputError('INPUT_BAD_SUBCOMMAND', `Unknown subcommand: ${subcommand}. Use: list, show`);
   }
 }
 
 if (process.argv[1] && (process.argv[1].endsWith('training-profile.js') || process.argv[1].endsWith('training-profile'))) {
-  run().catch((err) => { console.error(err.message || err); process.exit(1); });
+  run().catch(handleCliError);
 }

package/scripts/workflow-list.js

@@ -0,0 +1,61 @@
+#!/usr/bin/env node
+
+/**
+ * workflow-list.js — List workflow profiles for a project.
+ *
+ * Usage:
+ *   sdlab workflow list --project star-freight
+ *   sdlab workflow list --project star-freight --json
+ */
+
+import { getProjectName, parseArgs } from '../lib/args.js';
+import { getProjectRoot } from '../lib/paths.js';
+import { listWorkflowProfiles } from '../lib/workflow-profiles.js';
+
+export async function run(argv = process.argv.slice(2)) {
+  const { flags } = parseArgs(argv, {
+    flags: {
+      project: { type: 'string' },
+      json: { type: 'boolean' },
+    },
+    deprecated: { game: 'project' },
+  });
+
+  const projectName = flags.project || getProjectName(argv);
+  const projectRoot = getProjectRoot(projectName);
+  const profiles = await listWorkflowProfiles(projectRoot);
+
+  if (flags.json) {
+    console.log(JSON.stringify(profiles, null, 2));
+    return;
+  }
+
+  console.log(`\x1b[1msdlab workflow list\x1b[0m — ${projectName}\n`);
+
+  if (profiles.length === 0) {
+    console.log('  No workflow profiles found.');
+    console.log(`  Add profiles to projects/${projectName}/workflows/profiles/`);
+    return;
+  }
+
+  // Table header
+  const idW = Math.max(12, ...profiles.map(p => p.workflow_id.length));
+  const laneW = Math.max(6, ...profiles.map(p => p.lane_id.length));
+  const modeW = Math.max(7, ...profiles.map(p => (p.subject_mode || 'optional').length));
+  const outW = Math.max(11, ...profiles.map(p => p.output_mode.length));
+
+  const header = `  ${'WORKFLOW'.padEnd(idW)}  ${'LANE'.padEnd(laneW)}  ${'SUBJECT'.padEnd(modeW)}  ${'OUTPUT MODE'.padEnd(outW)}  COUNT`;
+  console.log(header);
+  console.log('  ' + '─'.repeat(header.length - 2));
+
+  for (const p of profiles) {
+    const line = `  ${p.workflow_id.padEnd(idW)}  ${p.lane_id.padEnd(laneW)}  ${(p.subject_mode || 'optional').padEnd(modeW)}  ${p.output_mode.padEnd(outW)}  ${p.output_count}`;
+    console.log(line);
+  }
+
+  console.log(`\n  ${profiles.length} workflow(s)`);
+}
+
+if (process.argv[1] && (process.argv[1].endsWith('workflow-list.js') || process.argv[1].endsWith('workflow-list'))) {
+  run().catch((err) => { console.error(err.message || err); process.exit(1); });
+}

package/scripts/workflow-show.js

@@ -0,0 +1,97 @@
+#!/usr/bin/env node
+
+/**
+ * workflow-show.js — Show details of a workflow profile.
+ *
+ * Usage:
+ *   sdlab workflow show character-portrait-set --project star-freight
+ *   sdlab workflow show character-portrait-set --json
+ */
+
+import { parseArgs, getProjectName } from '../lib/args.js';
+import { getProjectRoot } from '../lib/paths.js';
+import { getWorkflowProfile } from '../lib/workflow-profiles.js';
+
+export async function run(argv = process.argv.slice(2)) {
+  const { flags, positionals } = parseArgs(argv, {
+    flags: {
+      project: { type: 'string' },
+      json: { type: 'boolean' },
+    },
+    positionals: ['workflowId'],
+    deprecated: { game: 'project' },
+  });
+
+  const workflowId = positionals[0];
+  if (!workflowId) {
+    console.log('Usage: sdlab workflow show <workflow-id> [--project <name>]');
+    return;
+  }
+
+  const projectName = flags.project || getProjectName(argv);
+  const projectRoot = getProjectRoot(projectName);
+  const profile = await getWorkflowProfile(projectRoot, workflowId);
+
+  if (flags.json) {
+    console.log(JSON.stringify(profile, null, 2));
+    return;
+  }
+
+  console.log(`\x1b[1msdlab workflow show\x1b[0m — ${workflowId}\n`);
+  console.log(`  Label:        ${profile.label}`);
+  if (profile.description) {
+    console.log(`  Description:  ${profile.description}`);
+  }
+  console.log(`  Lane:         ${profile.lane_id}`);
+  console.log(`  Subject:      ${profile.subject_mode || 'optional'}`);
+  console.log(`  Output mode:  ${profile.output_mode}`);
+  console.log(`  Output count: ${profile.output_count}`);
+  console.log('');
+
+  console.log('  \x1b[1mPrompt strategy:\x1b[0m');
+  console.log(`    Style prefix:  ${profile.prompt_strategy.style_prefix.join(', ')}`);
+  console.log(`    Structure:     ${profile.prompt_strategy.structure}`);
+  console.log(`    Must include:  ${profile.prompt_strategy.must_include.join(', ')}`);
+  if (profile.prompt_strategy.optional_blocks?.length > 0) {
+    console.log(`    Optional:      ${profile.prompt_strategy.optional_blocks.join(', ')}`);
+  }
+  console.log('');
+
+  console.log('  \x1b[1mNegative strategy:\x1b[0m');
+  console.log(`    Must avoid:    ${profile.negative_strategy.must_avoid.join(', ')}`);
+  if (profile.negative_strategy.lane_specific_avoid?.length > 0) {
+    console.log(`    Lane avoid:    ${profile.negative_strategy.lane_specific_avoid.join(', ')}`);
+  }
+  console.log('');
+
+  console.log('  \x1b[1mCanon focus:\x1b[0m');
+  console.log(`    ${profile.canon_focus.join(', ')}`);
+  console.log('');
+
+  console.log('  \x1b[1mDrift guards:\x1b[0m');
+  for (const guard of profile.drift_guards) {
+    console.log(`    ⚠ ${guard}`);
+  }
+  console.log('');
+
+  console.log('  \x1b[1mRuntime defaults:\x1b[0m');
+  const rd = profile.runtime_defaults;
+  console.log(`    Adapter:   ${rd.adapter_target}`);
+  if (rd.width) console.log(`    Size:      ${rd.width}×${rd.height || rd.width}`);
+  if (rd.steps) console.log(`    Steps:     ${rd.steps}`);
+  if (rd.cfg) console.log(`    CFG:       ${rd.cfg}`);
+  if (rd.sampler) console.log(`    Sampler:   ${rd.sampler}`);
+  if (rd.seed_mode) console.log(`    Seed mode: ${rd.seed_mode}`);
+
+  if (profile.required_reference_roles?.length > 0) {
+    console.log('');
+    console.log(`  \x1b[1mRequired references:\x1b[0m ${profile.required_reference_roles.join(', ')}`);
+  }
+  if (profile.preferred_reference_tags?.length > 0) {
+    console.log(`  \x1b[1mPreferred tags:\x1b[0m ${profile.preferred_reference_tags.join(', ')}`);
+  }
+}
+
+if (process.argv[1] && (process.argv[1].endsWith('workflow-show.js') || process.argv[1].endsWith('workflow-show'))) {
+  run().catch((err) => { console.error(err.message || err); process.exit(1); });
+}

package/templates/domains/architecture/inputs/prompts/example-wave.json

@@ -0,0 +1,32 @@
+{
+  "wave": "wave1",
+  "description": "Architecture — first wave. Subject IDs match this domain's lane id_patterns (ext_, int_, street_) so `sdlab generate` will route each candidate into the correct lane instead of default_lane.",
+  "defaults": {
+    "checkpoint": "dreamshaperXL_v21TurboDPMSDE.safetensors",
+    "lora": { "name": "classipeintxl_v21.safetensors", "weight": 1.0 },
+    "width": 1024,
+    "height": 1024,
+    "steps": 8,
+    "cfg": 2.0,
+    "sampler": "dpmpp_sde",
+    "scheduler": "karras",
+    "negative": "photorealistic, photograph, 3d render, smooth CG, sharp photo detail"
+  },
+  "subjects": [
+    {
+      "id": "ext_landmark",
+      "variations": 2,
+      "prompt": "oil painting, visible brushstrokes, [DESCRIBE YOUR BUILDING — facade, elevation, architectural massing], painterly concept art, canvas grain"
+    },
+    {
+      "id": "int_hall",
+      "variations": 2,
+      "prompt": "oil painting, visible brushstrokes, [DESCRIBE YOUR INTERIOR — hall, chamber, spatial atmosphere], painterly concept art, canvas grain"
+    },
+    {
+      "id": "street_district",
+      "variations": 2,
+      "prompt": "oil painting, visible brushstrokes, [DESCRIBE YOUR STREETSCAPE — street-level view, urban fabric, district overview], painterly concept art, canvas grain"
+    }
+  ]
+}

package/templates/domains/architecture/terminology.json

@@ -8,12 +8,14 @@
   "null_faction_patterns": [],
   "id_fallbacks": {},
   "faction_context": {},
-  "training_profiles": {
-    "profile_id": "architecture-style",
-    "intended_use": "Architectural style LoRA for consistent worldbuilding",
-    "eligible_lanes": ["exterior", "interior", "streetscape"],
-    "minimum_review_threshold": 0.7,
-    "excluded_content": ["rejected"],
-    "export_format": "trl"
-  }
+  "training_profiles": [
+    {
+      "profile_id": "architecture-style",
+      "intended_use": "Architectural style LoRA for consistent worldbuilding",
+      "eligible_lanes": ["exterior", "interior", "streetscape"],
+      "minimum_review_threshold": 0.7,
+      "excluded_content": ["rejected"],
+      "export_format": "trl"
+    }
+  ]
 }

package/templates/domains/architecture/workflows/profiles/environment-moodboard.json

@@ -0,0 +1,62 @@
+{
+  "workflow_id": "environment-moodboard",
+  "label": "Environment Moodboard",
+  "description": "Explore architectural mood, palette, and spatial atmosphere.",
+  "lane_id": "exterior",
+  "subject_mode": "optional",
+  "output_mode": "moodboard",
+  "output_count": 6,
+  "required_reference_roles": [],
+  "preferred_reference_tags": ["exterior", "approved"],
+  "prompt_strategy": {
+    "style_prefix": [
+      "architectural concept art moodboard",
+      "strong spatial atmosphere",
+      "painterly rendering"
+    ],
+    "structure": "style_prefix, lane_goal, canon_focus, controlled_variation",
+    "must_include": [
+      "spatial composition",
+      "material palette",
+      "lighting atmosphere"
+    ],
+    "optional_blocks": [
+      "time of day note",
+      "weather note",
+      "era note"
+    ]
+  },
+  "negative_strategy": {
+    "must_avoid": [
+      "anachronistic elements",
+      "wrong architectural era",
+      "clean sterile surfaces",
+      "modern materials in historical context"
+    ],
+    "lane_specific_avoid": [
+      "character focus"
+    ],
+    "subject_specific_avoid": []
+  },
+  "canon_focus": [
+    "palette",
+    "material_language",
+    "lighting",
+    "scale_logic",
+    "era_logic"
+  ],
+  "drift_guards": [
+    "architectural era must remain consistent",
+    "material palette must match project canon",
+    "scale must read correctly"
+  ],
+  "runtime_defaults": {
+    "adapter_target": "comfyui",
+    "width": 1024,
+    "height": 1024,
+    "steps": 30,
+    "cfg": 6.5,
+    "sampler": "dpmpp_2m",
+    "seed_mode": "random"
+  }
+}