@mcptoolshop/style-dataset-lab 2.3.0 → 3.0.0

package/scripts/batch-sheet.js

@@ -0,0 +1,46 @@
+#!/usr/bin/env node
+
+/**
+ * batch-sheet.js — Re-render a batch sheet from saved manifest.
+ *
+ * Usage:
+ *   sdlab batch sheet batch_2025-06-30_001 --project star-freight
+ */
+
+import { parseArgs } from '../lib/args.js';
+import { getProjectRoot } from '../lib/paths.js';
+import { loadBatchManifest } from '../lib/batch-runs.js';
+import { getBatchMode } from '../lib/batch-modes.js';
+import { renderSheetHTML, saveSheet } from '../lib/batch-sheet-render.js';
+import { getBatchesDir } from '../lib/batch-runs.js';
+import { join } from 'node:path';
+import { inputError } from '../lib/errors.js';
+import { info } from '../lib/log.js';
+
+export async function run(argv = process.argv.slice(2)) {
+  const { flags, positionals } = parseArgs(argv, {
+    flags: {
+      project: { type: 'string', default: 'star-freight' },
+      batch: { type: 'string' },
+    },
+    deprecated: { game: 'project' },
+  });
+
+  const projectName = flags.project;
+  const projectRoot = getProjectRoot(projectName);
+  const batchId = positionals[0] || flags.batch;
+
+  if (!batchId) {
+    console.log('Usage: sdlab batch sheet <batch-id> [--project <name>]');
+    return;
+  }
+
+  const manifest = loadBatchManifest(projectRoot, batchId);
+  const mode = getBatchMode(projectRoot, manifest.mode_id);
+  const batchDir = join(getBatchesDir(projectRoot), batchId);
+
+  const html = renderSheetHTML({ manifest, mode, projectRoot, batchDir });
+  const sheetPath = await saveSheet(batchDir, 'primary-sheet.html', html);
+
+  info(`Sheet written: ${sheetPath}`);
+}

package/scripts/batch-show.js

@@ -0,0 +1,86 @@
+#!/usr/bin/env node
+
+/**
+ * batch-show.js — List batches or show batch details.
+ *
+ * Usage:
+ *   sdlab batch show --project star-freight          # list all batches
+ *   sdlab batch show batch_2025-06-30_001            # show specific batch
+ *   sdlab batch show batch_2025-06-30_001 --json     # as JSON
+ */
+
+import { parseArgs } from '../lib/args.js';
+import { getProjectRoot } from '../lib/paths.js';
+import { listBatches, loadBatchManifest } from '../lib/batch-runs.js';
+
+export async function run(argv = process.argv.slice(2)) {
+  const { flags, positionals } = parseArgs(argv, {
+    flags: {
+      project: { type: 'string', default: 'star-freight' },
+      batch: { type: 'string' },
+      json: { type: 'boolean' },
+    },
+    deprecated: { game: 'project' },
+  });
+
+  const projectName = flags.project;
+  const projectRoot = getProjectRoot(projectName);
+  const batchId = positionals[0] || flags.batch;
+
+  // List mode
+  if (!batchId) {
+    const batches = listBatches(projectRoot);
+    if (batches.length === 0) {
+      console.log('No batches found.');
+      return;
+    }
+    console.log(`\x1b[1mstyle-dataset-lab\x1b[0m batches (${projectName})`);
+    console.log('');
+    for (const id of batches) {
+      try {
+        const manifest = loadBatchManifest(projectRoot, id);
+        const mode = manifest.mode_id || '?';
+        const slots = manifest.summary?.total_slots || manifest.slots?.length || 0;
+        const ok = manifest.summary?.successful_slots ?? '?';
+        const dry = manifest.summary?.dry_run ? ' [dry]' : '';
+        const subject = manifest.subject_id ? ` (${manifest.subject_id})` : '';
+        console.log(`  ${id}  ${mode.padEnd(24)} ${ok}/${slots} slots${dry}${subject}`);
+      } catch {
+        console.log(`  ${id}  (manifest unreadable)`);
+      }
+    }
+    console.log('');
+    return;
+  }
+
+  // Detail mode
+  const manifest = loadBatchManifest(projectRoot, batchId);
+
+  if (flags.json) {
+    console.log(JSON.stringify(manifest, null, 2));
+    return;
+  }
+
+  console.log(`\x1b[1mstyle-dataset-lab\x1b[0m batch ${batchId}`);
+  console.log('');
+  console.log(`  Mode:      ${manifest.mode_id}`);
+  console.log(`  Project:   ${manifest.project_id}`);
+  if (manifest.subject_id) console.log(`  Subject:   ${manifest.subject_id}`);
+  if (manifest.theme) console.log(`  Theme:     ${manifest.theme}`);
+  console.log(`  Created:   ${manifest.created_at}`);
+  if (manifest.summary?.dry_run) console.log('  ⚠ DRY RUN');
+  console.log('');
+  console.log('  Slots:');
+  for (const slot of manifest.slots || []) {
+    const status = slot.selected_output ? '✓' : '○';
+    console.log(`    ${status} ${(slot.label || slot.slot_id).padEnd(24)} run=${slot.run_id}  ${slot.selected_output || ''}`);
+  }
+  console.log('');
+  if (manifest.sheet_paths?.length) {
+    console.log('  Sheets:');
+    for (const p of manifest.sheet_paths) {
+      console.log(`    ${p}`);
+    }
+    console.log('');
+  }
+}

package/scripts/brief-compile.js

@@ -0,0 +1,134 @@
+#!/usr/bin/env node
+
+/**
+ * brief-compile.js — Compile a generation brief from project truth.
+ *
+ * Usage:
+ *   sdlab brief compile --project star-freight --workflow character-portrait-set --subject kael_maren
+ *   sdlab brief compile --project star-freight --workflow environment-moodboard
+ *   sdlab brief compile --project star-freight --workflow character-portrait-set --subject kael_maren --reference sf_001,sf_018
+ *   sdlab brief compile --project star-freight --workflow character-portrait-set --subject kael_maren --output-count 8 --json
+ */
+
+import { parseArgs } from '../lib/args.js';
+import { getProjectRoot } from '../lib/paths.js';
+import { compileBrief, saveCompiledBrief } from '../lib/brief-compiler.js';
+import { info } from '../lib/log.js';
+
+export async function run(argv = process.argv.slice(2)) {
+  const { flags } = parseArgs(argv, {
+    flags: {
+      project: { type: 'string', default: 'star-freight' },
+      workflow: { type: 'string' },
+      subject: { type: 'string' },
+      asset: { type: 'string' },
+      'implementation-pack': { type: 'string' },
+      reference: { type: 'string' },
+      'output-count': { type: 'string' },
+      width: { type: 'string' },
+      height: { type: 'string' },
+      steps: { type: 'string' },
+      cfg: { type: 'string' },
+      sampler: { type: 'string' },
+      'seed-mode': { type: 'string' },
+      json: { type: 'boolean' },
+      'dry-run': { type: 'boolean' },
+    },
+    deprecated: { game: 'project' },
+  });
+
+  if (!flags.workflow) {
+    console.log('Usage: sdlab brief compile --workflow <id> [--subject <id>] [--project <name>]');
+    console.log('');
+    console.log('Options:');
+    console.log('  --workflow <id>         Workflow profile to use (required)');
+    console.log('  --subject <id>          Subject ID for subject-driven workflows');
+    console.log('  --asset <id>            Training asset reference');
+    console.log('  --implementation-pack <id>  Implementation pack reference');
+    console.log('  --reference <ids>       Comma-separated reference record IDs');
+    console.log('  --output-count <n>      Override output count');
+    console.log('  --width <px>            Override width');
+    console.log('  --height <px>           Override height');
+    console.log('  --steps <n>             Override steps');
+    console.log('  --cfg <n>               Override CFG scale');
+    console.log('  --sampler <name>        Override sampler');
+    console.log('  --seed-mode <mode>      Override seed mode (fixed|increment|random)');
+    console.log('  --json                  Output raw JSON');
+    console.log('  --dry-run               Preview without saving');
+    return;
+  }
+
+  const projectName = flags.project;
+  const projectRoot = getProjectRoot(projectName);
+
+  // Parse reference IDs
+  const referenceIds = flags.reference
+    ? flags.reference.split(',').map(s => s.trim()).filter(Boolean)
+    : undefined;
+
+  // Parse overrides
+  const overrides = {};
+  if (flags['output-count']) overrides.output_count = parseInt(flags['output-count'], 10);
+  if (flags.width) overrides.width = parseInt(flags.width, 10);
+  if (flags.height) overrides.height = parseInt(flags.height, 10);
+  if (flags.steps) overrides.steps = parseInt(flags.steps, 10);
+  if (flags.cfg) overrides.cfg = parseFloat(flags.cfg);
+  if (flags.sampler) overrides.sampler = flags.sampler;
+  if (flags['seed-mode']) overrides.seed_mode = flags['seed-mode'];
+
+  const brief = await compileBrief({
+    projectRoot,
+    projectId: projectName,
+    workflowId: flags.workflow,
+    subjectId: flags.subject,
+    assetRef: flags.asset,
+    implementationPackRef: flags['implementation-pack'],
+    referenceIds,
+    overrides,
+  });
+
+  if (flags.json) {
+    console.log(JSON.stringify(brief, null, 2));
+    if (!flags['dry-run']) {
+      await saveCompiledBrief(projectRoot, brief);
+    }
+    return;
+  }
+
+  if (!flags['dry-run']) {
+    const { jsonPath, mdPath } = await saveCompiledBrief(projectRoot, brief);
+    info(`\x1b[1msdlab brief compile\x1b[0m — ${projectName}\n`);
+    info(`  Brief ID:   ${brief.brief_id}`);
+    info(`  Workflow:   ${brief.workflow_id}`);
+    info(`  Lane:       ${brief.lane_id}`);
+    if (brief.subject_id) info(`  Subject:    ${brief.subject_id}`);
+    info(`  Outputs:    ${brief.expected_outputs.output_count}× ${brief.expected_outputs.output_mode}`);
+    info('');
+    info(`  Saved: ${jsonPath}`);
+    info(`         ${mdPath}`);
+  } else {
+    info(`\x1b[1msdlab brief compile\x1b[0m — dry run\n`);
+    info(`  Brief ID:   ${brief.brief_id}`);
+    info(`  Workflow:   ${brief.workflow_id}`);
+    info(`  Lane:       ${brief.lane_id}`);
+    if (brief.subject_id) info(`  Subject:    ${brief.subject_id}`);
+    info(`  Outputs:    ${brief.expected_outputs.output_count}× ${brief.expected_outputs.output_mode}`);
+    info('');
+    info('  Prompt:');
+    info(`    ${brief.prompt}`);
+    info('');
+    info('  Negative:');
+    info(`    ${brief.negative_prompt}`);
+    info('');
+    if (brief.drift_warnings?.length > 0) {
+      info('  Drift warnings:');
+      for (const w of brief.drift_warnings) {
+        info(`    \x1b[33m⚠\x1b[0m ${w}`);
+      }
+    }
+  }
+}
+
+if (process.argv[1] && (process.argv[1].endsWith('brief-compile.js') || process.argv[1].endsWith('brief-compile'))) {
+  run().catch((err) => { console.error(err.message || err); process.exit(1); });
+}

package/scripts/brief-show.js

@@ -0,0 +1,52 @@
+#!/usr/bin/env node
+
+/**
+ * brief-show.js — Show a compiled brief.
+ *
+ * Usage:
+ *   sdlab brief show brief_2026-04-15_001 --project star-freight
+ *   sdlab brief show brief_2026-04-15_001 --json
+ *   sdlab brief show brief_2026-04-15_001 --md
+ */
+
+import { parseArgs } from '../lib/args.js';
+import { getProjectRoot } from '../lib/paths.js';
+import { loadCompiledBrief } from '../lib/brief-compiler.js';
+import { renderBriefText, renderBriefMarkdown } from '../lib/brief-render.js';
+
+export async function run(argv = process.argv.slice(2)) {
+  const { flags, positionals } = parseArgs(argv, {
+    flags: {
+      project: { type: 'string', default: 'star-freight' },
+      json: { type: 'boolean' },
+      md: { type: 'boolean' },
+    },
+    positionals: ['briefId'],
+    deprecated: { game: 'project' },
+  });
+
+  const briefId = positionals[0];
+  if (!briefId) {
+    console.log('Usage: sdlab brief show <brief-id> [--project <name>] [--json] [--md]');
+    return;
+  }
+
+  const projectRoot = getProjectRoot(flags.project);
+  const brief = await loadCompiledBrief(projectRoot, briefId);
+
+  if (flags.json) {
+    console.log(JSON.stringify(brief, null, 2));
+    return;
+  }
+
+  if (flags.md) {
+    console.log(renderBriefMarkdown(brief));
+    return;
+  }
+
+  console.log(renderBriefText(brief));
+}
+
+if (process.argv[1] && (process.argv[1].endsWith('brief-show.js') || process.argv[1].endsWith('brief-show'))) {
+  run().catch((err) => { console.error(err.message || err); process.exit(1); });
+}

package/scripts/critique-show.js

@@ -0,0 +1,50 @@
+#!/usr/bin/env node
+
+/**
+ * critique-show.js — Display a saved critique report.
+ *
+ * Usage:
+ *   sdlab critique show --project star-freight --run run_2026-04-15_001
+ *   sdlab critique show --project star-freight --run run_2026-04-15_001 --json
+ *   sdlab critique show --project star-freight --run run_2026-04-15_001 --md
+ */
+
+import { parseArgs } from '../lib/args.js';
+import { getProjectRoot } from '../lib/paths.js';
+import { loadCritique } from '../lib/critique-engine.js';
+import { renderCritiqueMarkdown, renderCritiqueText } from '../lib/critique-render.js';
+
+export async function run(argv = process.argv.slice(2)) {
+  const { flags } = parseArgs(argv, {
+    flags: {
+      project: { type: 'string', default: 'star-freight' },
+      run: { type: 'string' },
+      json: { type: 'boolean' },
+      md: { type: 'boolean' },
+    },
+    deprecated: { game: 'project' },
+  });
+
+  if (!flags.run) {
+    console.log('Usage: sdlab critique show --run <id> [--project <name>]');
+    console.log('');
+    console.log('Options:');
+    console.log('  --run <id>        Run ID (required)');
+    console.log('  --json            Output raw JSON');
+    console.log('  --md              Output full Markdown');
+    return;
+  }
+
+  const projectName = flags.project;
+  const projectRoot = getProjectRoot(projectName);
+
+  const report = loadCritique(projectRoot, flags.run);
+
+  if (flags.json) {
+    console.log(JSON.stringify(report, null, 2));
+  } else if (flags.md) {
+    console.log(renderCritiqueMarkdown(report));
+  } else {
+    console.log(renderCritiqueText(report));
+  }
+}

package/scripts/critique.js

@@ -0,0 +1,70 @@
+#!/usr/bin/env node
+
+/**
+ * critique.js — Generate a critique report for a completed run.
+ *
+ * Usage:
+ *   sdlab critique --project star-freight --run run_2026-04-15_001
+ *   sdlab critique --project star-freight --run run_2026-04-15_001 --json
+ */
+
+import { parseArgs } from '../lib/args.js';
+import { getProjectRoot } from '../lib/paths.js';
+import { critiqueRun, saveCritique } from '../lib/critique-engine.js';
+import { renderCritiqueMarkdown, renderCritiqueText } from '../lib/critique-render.js';
+import { info } from '../lib/log.js';
+
+export async function run(argv = process.argv.slice(2)) {
+  const { flags } = parseArgs(argv, {
+    flags: {
+      project: { type: 'string', default: 'star-freight' },
+      run: { type: 'string' },
+      json: { type: 'boolean' },
+    },
+    deprecated: { game: 'project' },
+  });
+
+  if (!flags.run) {
+    console.log('Usage: sdlab critique --run <id> [--project <name>]');
+    console.log('');
+    console.log('Options:');
+    console.log('  --run <id>        Run to critique (required)');
+    console.log('  --json            Output raw JSON');
+    return;
+  }
+
+  const projectName = flags.project;
+  const projectRoot = getProjectRoot(projectName);
+
+  console.log(`\x1b[1mstyle-dataset-lab\x1b[0m critique`);
+  console.log(`  Project: ${projectName}`);
+  console.log(`  Run: ${flags.run}`);
+  console.log('');
+
+  // Generate critique
+  const report = await critiqueRun({
+    projectRoot,
+    projectId: projectName,
+    runId: flags.run,
+  });
+
+  // Save
+  const md = renderCritiqueMarkdown(report);
+  await saveCritique(projectRoot, flags.run, report, md);
+
+  if (flags.json) {
+    console.log(JSON.stringify(report, null, 2));
+  } else {
+    console.log(renderCritiqueText(report));
+    const action = report.recommended_action;
+    console.log(`Critique saved to: runs/${flags.run}/critique.json`);
+
+    if (action.mode === 'refine_from_one' && action.preferred_candidate) {
+      console.log('');
+      info(`Next: sdlab refine --run ${flags.run} --pick ${action.preferred_candidate}`);
+    } else if (action.mode === 'accept_one' && action.preferred_candidate) {
+      console.log('');
+      info(`Preferred candidate: ${action.preferred_candidate}`);
+    }
+  }
+}

package/scripts/doctor.js

@@ -41,6 +41,13 @@ const REQUIRED_DIRS = [
   'training/packages',
   'training/eval-runs',
   'training/implementations',
+  'workflows/profiles',
+  'workflows/batch-modes',
+  'briefs',
+  'runs',
+  'batches',
+  'selections',
+  'inbox/generated',
 ];
 
 function pass(msg) { console.log(`  \x1b[32m✓\x1b[0m ${msg}`); }
@@ -284,7 +291,168 @@ export async function run(argv = process.argv.slice(2)) {
     }
   }
 
-  // ── 9. Records sanity check ──
+  // ── 9. Workflow profile validation ──
+  const workflowDir = join(projectDir, 'workflows', 'profiles');
+  if (existsSync(workflowDir)) {
+    console.log('');
+    const wfFiles = readdirSync(workflowDir).filter(f => f.endsWith('.json'));
+    if (wfFiles.length > 0) {
+      const VALID_SUBJECT_MODES = ['required', 'optional', 'forbidden'];
+      const VALID_OUTPUT_MODES = ['portrait_set', 'expression_sheet', 'variant_pack', 'moodboard', 'silhouette_sheet', 'turnaround'];
+      const laneIds = new Set((lanes?.lanes || []).map(l => l.id));
+
+      let wfErrors = 0;
+      for (const file of wfFiles) {
+        const { data, error } = tryParseJson(join(workflowDir, file));
+        if (error) { fail(`workflows/profiles/${file} — invalid JSON: ${error}`); wfErrors++; continue; }
+
+        const missing = ['workflow_id', 'label', 'lane_id', 'output_mode', 'output_count',
+          'prompt_strategy', 'negative_strategy', 'canon_focus', 'drift_guards', 'runtime_defaults']
+          .filter(f => data[f] === undefined || data[f] === null);
+        if (missing.length > 0) {
+          fail(`workflows/profiles/${file} — missing fields: ${missing.join(', ')}`);
+          wfErrors++;
+          continue;
+        }
+
+        if (data.lane_id && laneIds.size > 0 && !laneIds.has(data.lane_id)) {
+          fail(`workflows/profiles/${file} — lane_id "${data.lane_id}" not found in lanes.json`);
+          wfErrors++;
+        }
+
+        if (data.subject_mode && !VALID_SUBJECT_MODES.includes(data.subject_mode)) {
+          fail(`workflows/profiles/${file} — invalid subject_mode "${data.subject_mode}"`);
+          wfErrors++;
+        }
+
+        if (!VALID_OUTPUT_MODES.includes(data.output_mode)) {
+          fail(`workflows/profiles/${file} — invalid output_mode "${data.output_mode}"`);
+          wfErrors++;
+        }
+
+        const ps = data.prompt_strategy;
+        if (!ps || !Array.isArray(ps.style_prefix) || !ps.structure || !Array.isArray(ps.must_include)) {
+          fail(`workflows/profiles/${file} — prompt_strategy needs style_prefix[], structure, must_include[]`);
+          wfErrors++;
+        }
+
+        const ns = data.negative_strategy;
+        if (!ns || !Array.isArray(ns.must_avoid)) {
+          fail(`workflows/profiles/${file} — negative_strategy needs must_avoid[]`);
+          wfErrors++;
+        }
+
+        if (!data.runtime_defaults?.adapter_target) {
+          fail(`workflows/profiles/${file} — runtime_defaults needs adapter_target`);
+          wfErrors++;
+        }
+      }
+
+      if (wfErrors === 0) {
+        pass(`${wfFiles.length} workflow profiles — all valid`);
+        passes++;
+      } else {
+        failures += wfErrors;
+      }
+    } else {
+      pass('workflows/profiles/ — empty (no workflows yet)');
+      passes++;
+    }
+  }
+
+  // ── 10. Batch mode validation ──
+  const batchModesDir = join(projectDir, 'workflows', 'batch-modes');
+  if (existsSync(batchModesDir)) {
+    console.log('');
+    const bmFiles = readdirSync(batchModesDir).filter(f => f.endsWith('.json'));
+    if (bmFiles.length > 0) {
+      const VALID_BATCH_TYPES = ['expression_sheet', 'environment_board', 'silhouette_pack', 'continuity_variants'];
+      const VALID_SUBJECT_MODES_BM = ['required', 'optional', 'forbidden'];
+      const VALID_LAYOUTS = ['grid', 'moodboard', 'strip', 'freeform'];
+      const wfFiles = existsSync(join(projectDir, 'workflows', 'profiles'))
+        ? readdirSync(join(projectDir, 'workflows', 'profiles')).filter(f => f.endsWith('.json')).map(f => f.replace('.json', ''))
+        : [];
+
+      let bmErrors = 0;
+      for (const file of bmFiles) {
+        const { data, error } = tryParseJson(join(batchModesDir, file));
+        if (error) { fail(`workflows/batch-modes/${file} — invalid JSON: ${error}`); bmErrors++; continue; }
+
+        if (!data.mode_id) { fail(`workflows/batch-modes/${file} — missing mode_id`); bmErrors++; }
+        if (!data.batch_type || !VALID_BATCH_TYPES.includes(data.batch_type)) {
+          fail(`workflows/batch-modes/${file} — invalid batch_type "${data.batch_type}"`);
+          bmErrors++;
+        }
+        if (data.subject_mode && !VALID_SUBJECT_MODES_BM.includes(data.subject_mode)) {
+          fail(`workflows/batch-modes/${file} — invalid subject_mode "${data.subject_mode}"`);
+          bmErrors++;
+        }
+        if (data.base_workflow_id && wfFiles.length > 0 && !wfFiles.includes(data.base_workflow_id)) {
+          fail(`workflows/batch-modes/${file} — base_workflow_id "${data.base_workflow_id}" not found in profiles`);
+          bmErrors++;
+        }
+        if (!Array.isArray(data.variant_plan) || data.variant_plan.length === 0) {
+          fail(`workflows/batch-modes/${file} — variant_plan must be non-empty array`);
+          bmErrors++;
+        } else {
+          const slotIds = data.variant_plan.map(s => s.slot_id);
+          const dupes = slotIds.filter((id, i) => slotIds.indexOf(id) !== i);
+          if (dupes.length > 0) {
+            fail(`workflows/batch-modes/${file} — duplicate slot_ids: ${[...new Set(dupes)].join(', ')}`);
+            bmErrors++;
+          }
+        }
+        if (data.assembly?.layout && !VALID_LAYOUTS.includes(data.assembly.layout)) {
+          fail(`workflows/batch-modes/${file} — invalid assembly.layout "${data.assembly.layout}"`);
+          bmErrors++;
+        }
+      }
+
+      if (bmErrors === 0) {
+        pass(`${bmFiles.length} batch modes — all valid`);
+        passes++;
+      } else {
+        failures += bmErrors;
+      }
+    } else {
+      pass('workflows/batch-modes/ — empty (no batch modes yet)');
+      passes++;
+    }
+  }
+
+  // ── 11. Runtime templates check ──
+  {
+    console.log('');
+    const runtimeDir = join(REPO_ROOT, 'runtime', 'comfyui');
+    if (existsSync(runtimeDir)) {
+      const templateFiles = readdirSync(runtimeDir).filter(f => f.endsWith('.json'));
+      if (templateFiles.length > 0) {
+        let templateErrors = 0;
+        for (const file of templateFiles) {
+          const { data, error } = tryParseJson(join(runtimeDir, file));
+          if (error) { fail(`runtime/comfyui/${file}: invalid JSON — ${error}`); templateErrors++; continue; }
+          if (!data.template_id) { fail(`runtime/comfyui/${file}: missing template_id`); templateErrors++; }
+          if (!data.compatible_modes || !Array.isArray(data.compatible_modes)) {
+            fail(`runtime/comfyui/${file}: missing compatible_modes[]`); templateErrors++;
+          }
+        }
+        if (templateErrors === 0) {
+          pass(`${templateFiles.length} runtime templates — all valid`);
+          passes++;
+        } else {
+          failures += templateErrors;
+        }
+      } else {
+        warn('runtime/comfyui/ — no templates found');
+        warnings++;
+      }
+    } else {
+      warn('runtime/comfyui/ — directory not found');
+      warnings++;
+    }
+  }
+
+  // ── 12. Records sanity check ──
   const recordsDir = join(projectDir, 'records');
   if (existsSync(recordsDir)) {
     console.log('');

package/scripts/init.js

@@ -40,6 +40,13 @@ const PROJECT_DIRS = [
   'training/packages',
   'training/eval-runs',
   'training/implementations',
+  'workflows/profiles',
+  'workflows/batch-modes',
+  'briefs',
+  'runs',
+  'batches',
+  'selections',
+  'inbox/generated',
 ];
 
 function isValidName(name) {
@@ -214,6 +221,21 @@ export async function run(argv = process.argv.slice(2)) {
     console.log(`  \x1b[32m✓\x1b[0m inputs/prompts/example-wave.json`);
   }
 
+  // Copy domain workflow profiles if available
+  if (domainDir) {
+    const domainWorkflowsDir = join(domainDir, 'workflows', 'profiles');
+    if (existsSync(domainWorkflowsDir)) {
+      const wfFiles = (await readdir(domainWorkflowsDir)).filter(f => f.endsWith('.json'));
+      for (const file of wfFiles) {
+        await copyFile(
+          join(domainWorkflowsDir, file),
+          join(projectDir, 'workflows', 'profiles', file)
+        );
+        console.log(`  \x1b[32m✓\x1b[0m workflows/profiles/${file}`);
+      }
+    }
+  }
+
   console.log('');
   console.log(`\x1b[32m✓\x1b[0m Project "${projectName}" initialized`);
   console.log('');