@mcptoolshop/style-dataset-lab 2.3.0 → 3.0.0

package/CHANGELOG.md

@@ -2,6 +2,131 @@
 
 All notable changes to this project will be documented in this file.
 
+## [2.6.0] - 2026-07-01
+
+### Added
+
+- **Batch production modes (Phase 4D)** — coordinated multi-slot generation with reviewable sheet output
+  - `sdlab batch generate --mode <id>` — execute a batch production mode (expression sheets, environment boards, etc.)
+  - `sdlab batch show [batch-id]` — list all batches or show batch details
+  - `sdlab batch sheet <batch-id>` — re-render batch sheet from saved manifest
+  - `--dry-run` flag prepares batch directory and briefs without submitting to ComfyUI
+- **Batch modes** (`lib/batch-modes.js`) — load, validate, and list batch mode definitions from `workflows/batch-modes/`
+- **Batch compiler** (`lib/batch-compiler.js`) — expand one batch mode into multiple slot briefs with controlled per-slot deltas
+- **Batch runs** (`lib/batch-runs.js`) — batch directory creation (`batch_YYYY-MM-DD_NNN`), coordinated slot execution, manifest save/load
+- **Batch sheet renderer** (`lib/batch-sheet-render.js`) — HTML review surfaces with CSS grid layout, dark theme, zero dependencies
+- **4 starter batch modes** for Star Freight: expression-sheet, environment-board, silhouette-pack, continuity-variants
+- **JSON schemas** for batch mode definitions and batch manifests (`schemas/`)
+- Doctor validates batch mode definitions (batch_type, subject_mode, slot uniqueness, layout, workflow references)
+- Init scaffolds `workflows/batch-modes/` and `batches/` directories
+## [3.0.0] - 2026-04-16
+
+### Added
+
+- **Selection + Reintegration (Phase 4E)** — close the production loop from generation back to corpus
+  - `sdlab select --run <id> --approve <files>` — select approved outputs from a run
+  - `sdlab select --batch <id> --approve <slot:file,...>` — select approved outputs from a batch
+  - `sdlab selection show [selection-id]` — list selections or show details
+  - `sdlab reingest selected --selection <id>` — re-ingest selected outputs as candidate records
+  - `--reason` and `--tags` flags for selection context
+  - `--dry-run` and `--json` output support
+- **Selection engine** (`lib/selections.js`) — create selection artifacts from runs or batches
+  - Selection ID generation (`selection_YYYY-MM-DD_NNN`)
+  - Run and batch selection with output validation
+  - Chosen files copied into `selections/<id>/chosen/`
+  - Manifest, summary.json, and summary.md written per selection
+- **Generated provenance** (`lib/generated-provenance.js`) — build provenance blocks for re-ingested records
+  - Traces back through run → brief → workflow → seed → config fingerprint
+  - Normalizes run and batch source context into a single shape
+- **Re-ingest from selections** (`lib/reingest-selected.js`) — create candidate records from selections
+  - Records carry `source: generated` provenance with full generation provenance block
+  - Images copied to `inbox/generated/`
+  - Records tagged: `generated`, `selected`, workflow ID, subject ID
+  - No auto-bypass around review — records are staged for normal curation
+  - Provenance log written as `provenance.jsonl`
+- **JSON schemas** for selections and generated records (`schemas/`)
+- Doctor validates new project directories (`selections/`, `inbox/generated/`)
+- Init scaffolds `selections/` and `inbox/generated/` directories
+
+### Changed
+
+- **README** rewritten to describe the full production loop: canon → dataset → training → brief → run → critique → batch → select → re-ingest
+- **Landing page** updated: new headline, description, 4-tab preview (Start, Dataset, Produce, Close the loop), 7 feature cards including production workflow and selection
+- **Handbook** updated: index shows production loop diagram, new [Production Loop](handbook/production-loop/) page with complete end-to-end walkthrough
+- **Package metadata** updated: description, keywords (`generation-workflow`, `batch-production`, `reintegration`), version badge
+- Version bumped to **v3.0.0** — the repo is now a full production workbench, not just a dataset preparation system
+## [2.5.0] - 2026-04-16
+
+### Added
+
+- **Critique + Refine loop (Phase 4C)** — inspect run outputs and generate focused next-pass briefs
+  - `sdlab critique --run <id>` — generate structured critique of a completed run
+  - `sdlab critique show --run <id>` — display saved critique (text, JSON, markdown)
+  - `sdlab refine --run <id> --pick <file>` — generate refined next-pass brief from critique
+  - CLI override flags: `--preserve`, `--push`, `--suppress` for manual delta control
+- **Critique engine** (`lib/critique-engine.js`) — brief-driven candidate analysis
+  - 10 critique dimensions activated by workflow canon focus and drift guards
+  - Per-candidate structured notes: strengths, drift issues, preserve/correct next pass
+  - Run-level recommendation: accept_one, refine_from_one, rerun_broader, discard_run
+  - Workflow-specific emphasis by output mode (portrait, expression, moodboard, etc.)
+- **Refine briefs** (`lib/refine-briefs.js`) — delta-layered brief generation
+  - Preserve/push/suppress instructions derived from critique + CLI overrides
+  - Prompt refinement: original prompt preserved, delta instructions appended
+  - Negative prompt extension: suppress items added without replacing existing negatives
+  - Refined briefs point back to parent brief + source run + picked candidate
+- **JSON schemas** for critique reports and refined briefs (`schemas/`)
+- Critique and refine artifacts stored in run directory: `runs/<id>/critique.json`, `runs/<id>/refine/`
+
+## [2.4.0] - 2026-04-16
+
+### Added
+
+- **ComfyUI runtime adapter (Phase 4B)** — execute compiled briefs through ComfyUI and capture run artifacts
+  - `sdlab run generate --brief <id>` — execute a brief through ComfyUI, capture outputs to runs/
+  - `sdlab run show <id>` — show run manifest and results
+  - `sdlab run list` — list all runs for a project
+  - `--dry-run` flag prepares run directory without submitting to ComfyUI
+  - `--seed <n>` override for reproducible generation
+- **Run management** (`lib/runtime-runs.js`) — run ID generation (`run_YYYY-MM-DD_NNN`), seed plans (fixed/increment/random), run directory preparation, manifest save/load
+- **ComfyUI workflow adapter** (`lib/adapters/comfyui-workflows.js`) — builds ComfyUI prompt graphs from compiled briefs, template resolution by output mode
+- **ComfyUI runner** (`lib/adapters/comfyui-runner.js`) — orchestrates seed plan → graph build → submit → poll → download → manifest for each image
+- **Run summaries** (`lib/run-summary.js`) — generates summary.json and summary.md in each run directory
+- **Runtime templates** (`runtime/comfyui/txt2img-standard.json`) — declarative workflow template metadata
+- Doctor validates runtime templates (Section 10)
+- `runs/` added to project scaffold
+
+## [2.3.0] - 2026-04-15
+
+### Added
+
+- **Production workbench spine (Phase 4A)** — workflow profiles and brief compiler
+  - `sdlab workflow list` — list workflow profiles for a project
+  - `sdlab workflow show <id>` — show workflow profile details
+  - `sdlab brief compile` — compile a deterministic generation brief from project truth
+  - `sdlab brief show <id>` — show compiled brief (text, JSON, or markdown)
+- **Workflow profiles** — production recipes defining output shape, canon constraints, drift guards, and runtime defaults
+  - 6 output modes: portrait_set, expression_sheet, variant_pack, moodboard, silhouette_sheet, turnaround
+  - 12 canon focus categories: silhouette, material_language, palette, anatomy, costume_logic, era_logic, scale_logic, lighting, surface_wear, gesture, composition, faction_read
+  - Subject mode enforcement: required, optional, forbidden
+- **Brief compiler** — merges 6 layers of project truth into a frozen generation contract:
+  - Project canon → lane config → subject identity → training asset hints → workflow profile → CLI overrides
+  - Structured prompt assembly (no freeform prompt soup)
+  - Deterministic output: same inputs produce identical briefs
+  - Config fingerprint (SHA-256) for change detection
+  - Outputs JSON + human-readable Markdown
+- **3 starter workflows for Star Freight**: character-portrait-set, expression-sheet, environment-moodboard
+- **10 domain template workflows** across 5 domains (game-art, character-design, creature-design, architecture, vehicle-mech)
+- **New library modules:** `lib/workflow-profiles.js`, `lib/brief-compiler.js`, `lib/brief-render.js`
+- **Doctor validates workflow profiles** — checks schema, lane references, subject mode, runtime defaults
+- **Init scaffolds `workflows/profiles/` and `briefs/`** directories and copies domain workflow templates
+
+### Key properties
+
+- Workflow profiles are NOT training profiles — they drive generation, not training
+- Briefs are frozen contracts — the creative runtime boundary between planning and execution
+- Subject constraints are hard when subject_mode = required (fail loudly if missing)
+- Drift guards appear as explicit warnings, never hidden in metadata
+
 ## [2.2.0] - 2026-04-16
 
 ### Added

package/README.md

@@ -11,11 +11,11 @@
   <a href="LICENSE"><img src="https://img.shields.io/badge/license-MIT-blue" alt="MIT License"></a>
 </p>
 
-Write your visual rules. Generate art. Judge every image against those rules. Ship the results as versioned, auditable training data.
+Write your visual rules. Generate art. Judge every image against those rules. Ship the results as versioned, auditable training data — then put trained models to work in real production workflows and feed the best outputs back into your corpus.
 
-Style Dataset Lab connects the thing you wrote down about your art style to the dataset you actually train from. You define a constitution — silhouette rules, palette constraints, material language, whatever matters for your project. The pipeline generates candidates, scores them against those rules, and packages the approved work into reproducible datasets where every record explains why it was included.
+Style Dataset Lab connects the thing you wrote down about your art style to the dataset you actually train from, and then closes the loop all the way through production. You define a constitution — silhouette rules, palette constraints, material language, whatever matters for your project. The pipeline generates candidates, scores them against those rules, and packages the approved work into reproducible datasets where every record explains why it was included.
 
-The loop closes: train a model, generate new outputs, score them against the same canon, re-ingest what passes. The dataset grows and the rules hold.
+Then the production workbench takes over: compile generation briefs from project truth, run them through ComfyUI, critique the outputs, batch-produce expression sheets and environment boards, select the best results, and re-ingest them as new candidates. The loop closes: produce, select, review, strengthen.
 
 ## The pipeline
 
@@ -35,18 +35,29 @@ sdlab snapshot create --project my-project
 sdlab split build
 sdlab export build
 
-# Build a training package and close the loop
+# Build a training package
 sdlab training-manifest create --profile character-style-lora
 sdlab training-package build
-sdlab eval-run create && sdlab eval-run score <id> --outputs results.jsonl
-sdlab reingest generated --source ./outputs --manifest <id>
+
+# Compile a production brief and run it
+sdlab brief compile --workflow character-portrait-set --subject kael_maren
+sdlab run generate --brief brief_2026-04-16_001
+
+# Critique, refine, batch-produce
+sdlab critique --run run_2026-04-16_001
+sdlab refine --run run_2026-04-16_001 --pick 001.png
+sdlab batch generate --mode expression-sheet --subject kael_maren
+
+# Select the best outputs and bring them back
+sdlab select --run run_2026-04-16_001 --approve 001.png,003.png
+sdlab reingest selected --selection selection_2026-04-16_001
 ```
 
-That last command is the point. Generated outputs come back through the same review process as everything else. The loop closes.
+That last command is the point. Selected outputs come back through the same review process as everything else. The corpus grows and the rules hold.
 
 ## What it produces
 
-Seven versioned, checksummed artifacts. Each links to its predecessors so you can trace any training record back to the rule that approved it.
+Seven dataset artifacts and a full production workbench. Each artifact links to its predecessors so you can trace any training record back to the rule that approved it.
 
 | Artifact | What it is |
 |----------|-----------|
@@ -58,6 +69,17 @@ Seven versioned, checksummed artifacts. Each links to its predecessors so you ca
 | **Eval scorecard** | Per-task pass/fail from scoring generated outputs against eval packs. |
 | **Implementation pack** | Prompt examples, known failures, continuity tests, and re-ingest guidance. |
 
+The production workbench adds:
+
+| Surface | What it does |
+|---------|-------------|
+| **Compiled brief** | Deterministic generation instruction from workflow profile + project truth. |
+| **Run** | Frozen execution artifact: brief + seeds + ComfyUI outputs + manifest. |
+| **Critique** | Structured multi-dimension evaluation of run outputs against canon. |
+| **Batch** | Coordinated multi-slot production (expression sheets, environment boards, silhouette packs). |
+| **Selection** | Creative decision artifact: which outputs were chosen, why, and where they came from. |
+| **Re-ingest** | Selected outputs return as candidate records with full generation provenance. |
+
 ## Why this exists
 
 Training data is the highest-leverage artifact in any visual AI pipeline. But most training data is a folder of images with no history, no judgment trail, and no connection to the style rules it was supposed to follow.
@@ -94,6 +116,12 @@ projects/my-project/
   splits/                Train/val/test partitions
   exports/               Versioned export packages
   training/              Profiles, manifests, packages, eval runs, implementations
+  workflows/             Workflow profiles + batch mode definitions
+  briefs/                Compiled generation briefs
+  runs/                  Execution artifacts (brief + outputs + manifest)
+  batches/               Coordinated multi-slot productions
+  selections/            Chosen outputs with reasons and provenance
+  inbox/generated/       Re-ingested images awaiting review
 ```
 
 ## Trust properties

package/bin/sdlab.js

@@ -43,6 +43,42 @@ const PROJECT_COMMANDS = {
   'migrate': '../scripts/migrate-records.js',
 };
 
+// Two-word commands under "workflow" namespace
+const WORKFLOW_COMMANDS = {
+  'list': '../scripts/workflow-list.js',
+  'show': '../scripts/workflow-show.js',
+};
+
+// Two-word commands under "brief" namespace
+const BRIEF_COMMANDS = {
+  'compile': '../scripts/brief-compile.js',
+  'show':    '../scripts/brief-show.js',
+};
+
+// Two-word commands under "run" namespace
+const RUN_COMMANDS = {
+  'generate': '../scripts/run-generate.js',
+  'show':     '../scripts/run-show.js',
+  'list':     '../scripts/run-list.js',
+};
+
+// Two-word commands under "critique" namespace
+const CRITIQUE_COMMANDS = {
+  'show': '../scripts/critique-show.js',
+};
+
+// Two-word commands under "batch" namespace
+const BATCH_COMMANDS = {
+  'generate': '../scripts/batch-generate.js',
+  'show':     '../scripts/batch-show.js',
+  'sheet':    '../scripts/batch-sheet.js',
+};
+
+// Two-word commands under "selection" namespace
+const SELECTION_COMMANDS = {
+  'show': '../scripts/selection-show.js',
+};
+
 function printHelp() {
   console.log(`\x1b[1msdlab\x1b[0m — Style Dataset Lab CLI\n`);
   console.log('Usage: sdlab <command> [options]\n');
@@ -99,6 +135,25 @@ function printHelp() {
   console.log('  reingest generated --source <dir>  Re-ingest generated outputs');
   console.log('  reingest audit                     Audit re-ingested record status');
   console.log('');
+  console.log('Production:');
+  console.log('  workflow list                      List workflow profiles');
+  console.log('  workflow show <id>                 Show workflow profile details');
+  console.log('  brief compile                      Compile generation brief from project truth');
+  console.log('  brief show <id>                    Show compiled brief');
+  console.log('  run generate --brief <id>          Execute brief through ComfyUI');
+  console.log('  run show <id>                      Show run details');
+  console.log('  run list                           List all runs');
+  console.log('  critique --run <id>                Critique a completed run');
+  console.log('  critique show --run <id>           Show saved critique');
+  console.log('  refine --run <id> --pick <file>    Generate refined next-pass brief');
+  console.log('  batch generate --mode <id>         Execute a batch production mode');
+  console.log('  batch show [batch-id]              List batches or show details');
+  console.log('  batch sheet <batch-id>             Re-render batch sheet from manifest');
+  console.log('  select --run <id> --approve <files> Select approved outputs from a run');
+  console.log('  select --batch <id> --approve ...   Select approved outputs from a batch');
+  console.log('  selection show [selection-id]       List selections or show details');
+  console.log('  reingest selected --selection <id>  Re-ingest selected outputs as records');
+  console.log('');
   console.log('Options:');
   console.log('  --project <name>     Project to operate on (default: star-freight)');
   console.log('  --game <name>        Deprecated alias for --project');
@@ -140,6 +195,80 @@ async function main() {
     return;
   }
 
+  // Handle "workflow <subcommand>" two-word form
+  if (command === 'workflow' && args[1] && WORKFLOW_COMMANDS[args[1]]) {
+    commandArgs = args.slice(2);
+    const modulePath = WORKFLOW_COMMANDS[args[1]];
+    const mod = await import(modulePath);
+    await mod.run(commandArgs);
+    return;
+  }
+
+  // Handle "brief <subcommand>" two-word form
+  if (command === 'brief' && args[1] && BRIEF_COMMANDS[args[1]]) {
+    commandArgs = args.slice(2);
+    const modulePath = BRIEF_COMMANDS[args[1]];
+    const mod = await import(modulePath);
+    await mod.run(commandArgs);
+    return;
+  }
+
+  // Handle "run <subcommand>" two-word form
+  if (command === 'run' && args[1] && RUN_COMMANDS[args[1]]) {
+    commandArgs = args.slice(2);
+    const modulePath = RUN_COMMANDS[args[1]];
+    const mod = await import(modulePath);
+    await mod.run(commandArgs);
+    return;
+  }
+
+  // Handle "critique" — bare or "critique show" two-word form
+  if (command === 'critique') {
+    if (args[1] && CRITIQUE_COMMANDS[args[1]]) {
+      commandArgs = args.slice(2);
+      const modulePath = CRITIQUE_COMMANDS[args[1]];
+      const mod = await import(modulePath);
+      await mod.run(commandArgs);
+      return;
+    }
+    // Bare "critique" → generate critique
+    const mod = await import('../scripts/critique.js');
+    await mod.run(commandArgs);
+    return;
+  }
+
+  // Handle "refine" — single command
+  if (command === 'refine') {
+    const mod = await import('../scripts/refine.js');
+    await mod.run(commandArgs);
+    return;
+  }
+
+  // Handle "batch <subcommand>" two-word form
+  if (command === 'batch' && args[1] && BATCH_COMMANDS[args[1]]) {
+    commandArgs = args.slice(2);
+    const modulePath = BATCH_COMMANDS[args[1]];
+    const mod = await import(modulePath);
+    await mod.run(commandArgs);
+    return;
+  }
+
+  // Handle "select" — single command
+  if (command === 'select') {
+    const mod = await import('../scripts/select.js');
+    await mod.run(commandArgs);
+    return;
+  }
+
+  // Handle "selection <subcommand>" two-word form
+  if (command === 'selection' && args[1] && SELECTION_COMMANDS[args[1]]) {
+    commandArgs = args.slice(2);
+    const modulePath = SELECTION_COMMANDS[args[1]];
+    const mod = await import(modulePath);
+    await mod.run(commandArgs);
+    return;
+  }
+
   const modulePath = COMMANDS[command];
   if (!modulePath) {
     throw inputError('INPUT_UNKNOWN_COMMAND', `Unknown command: ${command}`, 'Run "sdlab --help" for available commands.');

package/lib/adapters/comfyui-runner.js

@@ -0,0 +1,170 @@
+/**
+ * ComfyUI runner — executes a brief through ComfyUI and captures outputs.
+ *
+ * Orchestrates: seed plan → graph build → submit → poll → download → manifest.
+ * Each image in the seed plan becomes one submission to ComfyUI.
+ */
+
+import { writeFile, mkdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { comfyHealth, submitAndWait, downloadImage } from '../comfyui.js';
+import { buildWorkflowGraph, resolveTemplateId } from './comfyui-workflows.js';
+import { buildSeedPlan, prepareRunDir, saveRunManifest } from '../runtime-runs.js';
+import { loadProjectConfig } from '../config.js';
+import { log, info, warn } from '../log.js';
+import { runtimeError } from '../errors.js';
+
+/**
+ * Execute a brief: build graphs, submit to ComfyUI, capture outputs.
+ *
+ * @param {Object} opts
+ * @param {string} opts.projectRoot — absolute project path
+ * @param {string} opts.projectName — project name
+ * @param {Object} opts.brief — compiled brief object
+ * @param {number} [opts.baseSeed] — override base seed
+ * @param {boolean} [opts.dryRun] — if true, prepare run dir but do not submit
+ * @returns {Promise<Object>} — manifest
+ */
+export async function executeRun({ projectRoot, projectName, brief, baseSeed, dryRun = false }) {
+  const config = loadProjectConfig(projectRoot);
+  const defaults = config.meta?.defaults ?? {};
+  const comfyUrl = defaults.comfy_url || process.env.COMFY_URL || 'http://127.0.0.1:8188';
+
+  // Resolve template
+  const outputMode = brief.expected_outputs?.output_mode || 'portrait_set';
+  const templateId = resolveTemplateId(outputMode);
+  const outputCount = brief.expected_outputs?.output_count || brief.runtime_plan?.output_count || 4;
+
+  // Build seed plan
+  const seedMode = brief.runtime_plan?.seed_mode || 'increment';
+  const seedPlan = buildSeedPlan({ seedMode, outputCount, baseSeed });
+
+  // Prepare run directory
+  const { runId, runDir } = await prepareRunDir(projectRoot, brief);
+
+  info(`Run ${runId} — ${outputCount} images, seed mode: ${seedMode}, base: ${seedPlan.base_seed}`);
+  info(`Template: ${templateId}, ComfyUI: ${comfyUrl}`);
+
+  // Health check
+  if (!dryRun) {
+    const healthy = await comfyHealth(comfyUrl);
+    if (!healthy) {
+      throw runtimeError(
+        'COMFYUI_OFFLINE',
+        `ComfyUI not reachable at ${comfyUrl}`,
+        'Start ComfyUI or set COMFY_URL / project defaults.comfy_url'
+      );
+    }
+    info('ComfyUI online');
+  }
+
+  const outputs = [];
+  const errors = [];
+
+  for (let i = 0; i < outputCount; i++) {
+    const seed = seedPlan.seeds[i];
+    const imageIndex = String(i + 1).padStart(3, '0');
+
+    log(`  [${i + 1}/${outputCount}] seed: ${seed}`);
+
+    if (dryRun) {
+      outputs.push({
+        index: i,
+        seed,
+        status: 'dry_run',
+        filename: `${imageIndex}.png`,
+      });
+      continue;
+    }
+
+    const startMs = Date.now();
+
+    try {
+      // Build graph
+      const { nodes } = buildWorkflowGraph({
+        brief,
+        projectDefaults: defaults,
+        seed,
+      });
+
+      // Submit and wait
+      const result = await submitAndWait(nodes, comfyUrl, {
+        clientPrefix: `sdl-run-${runId}`,
+      });
+
+      const elapsed = Date.now() - startMs;
+
+      // Extract output image
+      const nodeOutputs = result.outputs || {};
+      let imageFile = null;
+      let imageSubfolder = '';
+      for (const nodeOut of Object.values(nodeOutputs)) {
+        if (nodeOut.images && nodeOut.images.length > 0) {
+          imageFile = nodeOut.images[0].filename;
+          imageSubfolder = nodeOut.images[0].subfolder || '';
+          break;
+        }
+      }
+
+      if (!imageFile) {
+        warn(`  No output image for seed ${seed}`);
+        outputs.push({ index: i, seed, status: 'no_output', elapsed_ms: elapsed });
+        continue;
+      }
+
+      // Download and save
+      const imgData = await downloadImage(imageFile, imageSubfolder, comfyUrl);
+      const destFilename = `${imageIndex}.png`;
+      await writeFile(join(runDir, 'outputs', destFilename), imgData);
+
+      outputs.push({
+        index: i,
+        seed,
+        status: 'ok',
+        filename: destFilename,
+        bytes: imgData.length,
+        elapsed_ms: elapsed,
+        comfy_filename: imageFile,
+      });
+
+      log(`    ✓ ${destFilename} (${imgData.length} bytes, ${(elapsed / 1000).toFixed(1)}s)`);
+    } catch (err) {
+      const elapsed = Date.now() - startMs;
+      warn(`    ✗ seed ${seed}: ${err.message}`);
+      errors.push({ index: i, seed, error: err.message });
+      outputs.push({
+        index: i,
+        seed,
+        status: 'error',
+        error: err.message,
+        elapsed_ms: elapsed,
+      });
+    }
+  }
+
+  // Build manifest
+  const manifest = {
+    run_id: runId,
+    brief_id: brief.brief_id,
+    project_id: brief.project_id,
+    workflow_template_id: templateId,
+    adapter_target: 'comfyui',
+    output_mode: outputMode,
+    output_count: outputCount,
+    created_at: new Date().toISOString(),
+    seed_plan: seedPlan,
+    comfy_url: comfyUrl,
+    checkpoint: defaults.checkpoint,
+    loras: defaults.loras || [],
+    runtime_plan: brief.runtime_plan,
+    outputs,
+    errors,
+    dry_run: dryRun,
+    success_count: outputs.filter(o => o.status === 'ok' || o.status === 'dry_run').length,
+    error_count: errors.length,
+  };
+
+  await saveRunManifest(runDir, manifest);
+
+  return manifest;
+}