@mcptoolshop/style-dataset-lab 2.3.0 → 3.0.1

package/lib/split.js

@@ -13,8 +13,9 @@ import { join } from 'node:path';
 import { existsSync } from 'node:fs';
 import { createHash, randomBytes } from 'node:crypto';
 import { loadProjectConfig, loadSplitProfile, detectLane } from './config.js';
-import { loadSnapshot, loadSnapshotIncluded } from './snapshot.js';
+import { loadSnapshot, loadSnapshotIncluded, SCHEMA_VERSION, checkManifestVersion } from './snapshot.js';
 import { loadRecord } from './records.js';
+import { inputError } from './errors.js';
 
 /**
  * Mulberry32 — deterministic 32-bit PRNG.
@@ -119,6 +120,74 @@ function buildAncestorMap(records) {
   return ancestorMap;
 }
 
+/**
+ * Allocate `total` items across train/val/test using largest-remainder rounding,
+ * guaranteeing each partition receives at least 1 when total >= 3.
+ */
+function allocateLargestRemainder(total, profile) {
+  if (total <= 0) return { train: 0, val: 0, test: 0 };
+
+  const ratios = {
+    train: profile.train_ratio,
+    val: profile.val_ratio,
+    test: profile.test_ratio,
+  };
+
+  // Ideal fractional counts
+  const ideal = {
+    train: total * ratios.train,
+    val: total * ratios.val,
+    test: total * ratios.test,
+  };
+
+  // Floor + sort by fractional remainder desc (tie-break by partition name)
+  const base = {
+    train: Math.floor(ideal.train),
+    val: Math.floor(ideal.val),
+    test: Math.floor(ideal.test),
+  };
+  let assigned = base.train + base.val + base.test;
+
+  const remainders = [
+    ['train', ideal.train - base.train],
+    ['val', ideal.val - base.val],
+    ['test', ideal.test - base.test],
+  ].sort((a, b) => {
+    if (b[1] !== a[1]) return b[1] - a[1];
+    return a[0].localeCompare(b[0]);
+  });
+
+  let ri = 0;
+  while (assigned < total) {
+    base[remainders[ri % remainders.length][0]]++;
+    assigned++;
+    ri++;
+  }
+
+  // Min-1 rebalance: if total >= 3 and any partition is 0, take from the
+  // largest partition. Deterministic — always steal from 'train' first when tied.
+  if (total >= 3) {
+    const partitionOrder = ['train', 'val', 'test'];
+    for (const part of partitionOrder) {
+      if (base[part] === 0) {
+        // find largest (ties broken by name asc to stay deterministic)
+        const donor = partitionOrder
+          .filter(p => p !== part && base[p] > 1)
+          .sort((a, b) => {
+            if (base[b] !== base[a]) return base[b] - base[a];
+            return a.localeCompare(b);
+          })[0];
+        if (donor) {
+          base[donor]--;
+          base[part]++;
+        }
+      }
+    }
+  }
+
+  return base;
+}
+
 /**
  * Create a split from a snapshot.
  *
@@ -156,14 +225,34 @@ export async function createSplit(projectRoot, snapshotId, profile, options = {}
     familyMap.get(family).push(record);
   }
 
-  // Detect primary lane per family (first record's lane)
+  // D-002: Deterministic primary lane per family = majority vote; ties
+  // broken by lexicographic lane name. Record the per-family decision
+  // for the audit so the chosen lane is explainable.
   const familyLane = new Map();
+  const familyLaneDecisions = [];
   for (const [family, recs] of familyMap) {
-    const first = recs[0];
-    const prompt = first.provenance?.prompt || '';
-    const lane = detectLane(first.id, prompt, config.lanes);
-    familyLane.set(family, lane);
+    const laneCounts = new Map();
+    for (const rec of recs) {
+      const prompt = rec.provenance?.prompt || '';
+      const recLane = detectLane(rec.id, prompt, config.lanes);
+      laneCounts.set(recLane, (laneCounts.get(recLane) || 0) + 1);
+    }
+    // Sort: count desc, then lane name asc. Deterministic winner.
+    const ranked = [...laneCounts.entries()].sort((a, b) => {
+      if (b[1] !== a[1]) return b[1] - a[1];
+      return a[0].localeCompare(b[0]);
+    });
+    const [chosenLane, chosenCount] = ranked[0];
+    familyLane.set(family, chosenLane);
+    familyLaneDecisions.push({
+      family,
+      chosen_lane: chosenLane,
+      chosen_count: chosenCount,
+      record_count: recs.length,
+      lane_counts: Object.fromEntries(laneCounts),
+    });
   }
+  familyLaneDecisions.sort((a, b) => a.family.localeCompare(b.family));
 
   // Group families by lane
   const laneGroups = new Map(); // lane → [family]
@@ -173,7 +262,8 @@ export async function createSplit(projectRoot, snapshotId, profile, options = {}
   }
 
   // Split families per lane using seeded PRNG
-  const rng = mulberry32(profile.seed || 42);
+  // D-011: seed:0 is a valid seed; use nullish coalescing so 0 is honored.
+  const rng = mulberry32(profile.seed ?? 42);
   const trainFamilies = new Set();
   const valFamilies = new Set();
   const testFamilies = new Set();
@@ -191,11 +281,17 @@ export async function createSplit(projectRoot, snapshotId, profile, options = {}
       continue;
     }
 
-    // Assign by ratio
+    // D-004: Largest-remainder allocation guarantees min-1 per partition
+    // when total >= 3, and emits a warning if any partition ends up at 0.
     const total = shuffled.length;
-    const trainCount = Math.round(total * profile.train_ratio);
-    const valCount = Math.round(total * profile.val_ratio);
-    // test gets the rest
+    const { train: trainCount, val: valCount, test: testCount } =
+      allocateLargestRemainder(total, profile);
+
+    if (total >= 3 && (trainCount === 0 || valCount === 0 || testCount === 0)) {
+      warnings.push(
+        `lane "${lane}": partition size hit 0 after allocation (train=${trainCount}, val=${valCount}, test=${testCount}) — ratios may be extreme`,
+      );
+    }
 
     let idx = 0;
     for (let i = 0; i < trainCount && idx < total; i++, idx++) {
@@ -226,7 +322,14 @@ export async function createSplit(projectRoot, snapshotId, profile, options = {}
     if (trainFamilies.has(family)) trainRecords.push(record.id);
     else if (valFamilies.has(family)) valRecords.push(record.id);
     else if (testFamilies.has(family)) testRecords.push(record.id);
-    else trainRecords.push(record.id); // fallback: unassigned → train
+    else {
+      // D-003: unassigned family means the familyMap build pass disagreed
+      // with the assignment pass — never silently rescue; surface the bug.
+      throw new Error(
+        `unassigned family for record ${record.id} (family=${family}) — ` +
+        `this indicates a bug in family resolution; the record was not placed in train/val/test`,
+      );
+    }
   }
 
   // Sort for deterministic output
@@ -237,9 +340,9 @@ export async function createSplit(projectRoot, snapshotId, profile, options = {}
   // Leakage audit
   const leakageIssues = auditLeakage(familyMap, trainRecords, valRecords, testRecords);
 
-  // Lane balance audit
+  // Lane balance audit (DB-005: includes deviation from profile ratios)
   const laneBalance = auditLaneBalance(
-    records, trainRecords, valRecords, testRecords, config.lanes
+    records, trainRecords, valRecords, testRecords, config.lanes, profile
   );
 
   // Write output (skip if dry run)
@@ -248,9 +351,19 @@ export async function createSplit(projectRoot, snapshotId, profile, options = {}
     return { splitId, train: trainRecords.length, val: valRecords.length, test: testRecords.length };
   }
   const splitDir = join(projectRoot, 'splits', splitId);
+  // D-005: refuse to silently overwrite on ID collision.
+  if (existsSync(splitDir)) {
+    throw inputError(
+      'SPLIT_ID_COLLISION',
+      `Split directory already exists: ${splitDir}`,
+      'Retry to generate a fresh split ID.',
+    );
+  }
   await mkdir(splitDir, { recursive: true });
 
   const manifest = {
+    // DB-001 / DB-006: stamp manifest schema version
+    schema_version: SCHEMA_VERSION,
     split_id: splitId,
     created_at: new Date().toISOString(),
     created_by: 'sdlab-split-v1',
@@ -280,6 +393,9 @@ export async function createSplit(projectRoot, snapshotId, profile, options = {}
       val: valFamilies.size,
       test: testFamilies.size,
     },
+    // D-002: record the deterministic per-family lane decision for replay.
+    family_lane_decisions: familyLaneDecisions,
+    warnings,
   };
 
   await writeFile(join(splitDir, 'split.json'), JSON.stringify(manifest, null, 2) + '\n');
@@ -322,8 +438,13 @@ function auditLeakage(familyMap, trainIds, valIds, testIds) {
 
 /**
  * Audit lane balance across splits.
+ *
+ * DB-005: includes deviation-from-profile metric per lane + overall score.
+ * A lane that shows train=100/val=0/test=0 and another at 33/33/33 look
+ * equally "balanced" by percentage alone — deviation makes the real gap
+ * between intent and reality visible at a glance.
  */
-function auditLaneBalance(records, trainIds, valIds, testIds, lanesConfig) {
+function auditLaneBalance(records, trainIds, valIds, testIds, lanesConfig, profile) {
   const trainSet = new Set(trainIds);
   const valSet = new Set(valIds);
   const testSet = new Set(testIds);
@@ -339,14 +460,49 @@ function auditLaneBalance(records, trainIds, valIds, testIds, lanesConfig) {
     else if (testSet.has(record.id)) balance[lane].test++;
   }
 
-  // Compute percentages
+  // Compute percentages + deviation from profile ratios (DB-005)
+  const targetTrain = (profile?.train_ratio ?? 0) * 100;
+  const targetVal = (profile?.val_ratio ?? 0) * 100;
+  const targetTest = (profile?.test_ratio ?? 0) * 100;
+
+  let overallDeviation = 0;
+  const deviations = {};
+
   for (const lane of Object.keys(balance)) {
     const b = balance[lane];
     b.train_pct = b.total > 0 ? +(b.train / b.total * 100).toFixed(1) : 0;
     b.val_pct = b.total > 0 ? +(b.val / b.total * 100).toFixed(1) : 0;
     b.test_pct = b.total > 0 ? +(b.test / b.total * 100).toFixed(1) : 0;
+
+    // DB-005: absolute deviation from profile target per partition
+    const devTrain = Math.abs(b.train_pct - targetTrain);
+    const devVal = Math.abs(b.val_pct - targetVal);
+    const devTest = Math.abs(b.test_pct - targetTest);
+    // Lane deviation: sum of per-partition absolute deviations (max ~200)
+    const laneDev = +(devTrain + devVal + devTest).toFixed(1);
+    b.deviation_from_target = {
+      train: +devTrain.toFixed(1),
+      val: +devVal.toFixed(1),
+      test: +devTest.toFixed(1),
+      total: laneDev,
+    };
+    deviations[lane] = laneDev;
+    overallDeviation += laneDev;
   }
 
+  // Attach a summary so the operator sees the signal without scanning per-lane rows.
+  balance._summary = {
+    target_ratios_pct: {
+      train: +targetTrain.toFixed(1),
+      val: +targetVal.toFixed(1),
+      test: +targetTest.toFixed(1),
+    },
+    overall_deviation_score: +overallDeviation.toFixed(1),
+    worst_lane: Object.keys(deviations).length > 0
+      ? Object.entries(deviations).sort((a, b) => b[1] - a[1])[0][0]
+      : null,
+  };
+
   return balance;
 }
 
@@ -358,7 +514,9 @@ export async function loadSplit(projectRoot, splitId) {
   if (!existsSync(path)) {
     throw new Error(`Split "${splitId}" not found at ${path}`);
   }
-  return JSON.parse(await readFile(path, 'utf-8'));
+  const manifest = JSON.parse(await readFile(path, 'utf-8'));
+  checkManifestVersion(manifest, 'split');
+  return manifest;
 }
 
 /**

package/lib/training-manifests.js

@@ -12,8 +12,9 @@ import { existsSync } from 'node:fs';
 import { createHash, randomBytes } from 'node:crypto';
 import { loadExport } from './export.js';
 import { loadTrainingProfile } from './training-profiles.js';
-import { computeConfigFingerprint } from './snapshot.js';
+import { computeConfigFingerprint, SCHEMA_VERSION, checkManifestVersion } from './snapshot.js';
 import { listEvalPacks } from './eval-pack.js';
+import { inputError } from './errors.js';
 
 /**
  * Generate a training manifest ID: tm-YYYYMMDD-HHMMSS-XXXX
@@ -64,6 +65,8 @@ export async function createTrainingManifest(projectRoot, exportId, profileId, o
 
   const manifestId = generateManifestId();
   const manifest = {
+    // DB-001 / DB-006: stamp manifest schema version
+    schema_version: SCHEMA_VERSION,
     training_manifest_id: manifestId,
     created_at: new Date().toISOString(),
     created_by: 'sdlab-training-manifest-v1',
@@ -89,7 +92,16 @@ export async function createTrainingManifest(projectRoot, exportId, profileId, o
   // Write manifest
   const dir = join(projectRoot, 'training', 'manifests');
   await mkdir(dir, { recursive: true });
-  await writeFile(join(dir, `${manifestId}.json`), JSON.stringify(manifest, null, 2) + '\n');
+  const manifestPath = join(dir, `${manifestId}.json`);
+  // D-005: refuse to silently overwrite on ID collision.
+  if (existsSync(manifestPath)) {
+    throw inputError(
+      'TRAINING_MANIFEST_ID_COLLISION',
+      `Training manifest file already exists: ${manifestPath}`,
+      'Retry to generate a fresh manifest ID.',
+    );
+  }
+  await writeFile(manifestPath, JSON.stringify(manifest, null, 2) + '\n');
 
   return { manifestId, exportId, profileId };
 }
@@ -139,7 +151,9 @@ export async function loadTrainingManifest(projectRoot, manifestId) {
   if (!existsSync(path)) {
     throw new Error(`Training manifest "${manifestId}" not found at ${path}`);
   }
-  return JSON.parse(await readFile(path, 'utf-8'));
+  const manifest = JSON.parse(await readFile(path, 'utf-8'));
+  checkManifestVersion(manifest, 'training-manifest');
+  return manifest;
 }
 
 /**

package/lib/training-packages.js

@@ -15,6 +15,8 @@ import { loadTrainingProfile } from './training-profiles.js';
 import { loadSplitPartition } from './split.js';
 import { loadRecord } from './records.js';
 import { loadProjectConfig, detectLane, detectGroup } from './config.js';
+import { inputError } from './errors.js';
+import { SCHEMA_VERSION, checkManifestVersion } from './snapshot.js';
 
 /**
  * Generate a training package ID: tp-YYYYMMDD-HHMMSS-XXXX
@@ -63,6 +65,14 @@ export async function buildTrainingPackage(projectRoot, manifestId, options = {}
   const recordsDir = join(projectRoot, 'records');
   const packageId = generatePackageId();
   const packageDir = join(projectRoot, 'training', 'packages', packageId);
+  // D-005: refuse to silently overwrite on ID collision.
+  if (existsSync(packageDir)) {
+    throw inputError(
+      'TRAINING_PACKAGE_ID_COLLISION',
+      `Training package directory already exists: ${packageDir}`,
+      'Retry to generate a fresh package ID.',
+    );
+  }
 
   // Load split partitions
   const partitions = {};
@@ -105,19 +115,10 @@ export async function buildTrainingPackage(projectRoot, manifestId, options = {}
 
   totalImages = adapterResult.imageCount || 0;
 
-  // Generate checksums for all files in the package
-  const checksumEntries = [];
-  const allFiles = await collectFiles(packageDir);
-  for (const filePath of allFiles.sort()) {
-    const relPath = relative(packageDir, filePath);
-    if (relPath === 'checksums.txt') continue;
-    const hash = await sha256File(filePath);
-    checksumEntries.push(`SHA256 (${relPath}) = ${hash}`);
-  }
-  await writeFile(join(packageDir, 'checksums.txt'), checksumEntries.join('\n') + '\n');
-
-  // Write package manifest (last — references everything)
+  // D-015: Write manifest + README FIRST so they are covered by checksums.
   const packageManifest = {
+    // DB-001 / DB-006: stamp manifest schema version
+    schema_version: SCHEMA_VERSION,
     training_package_id: packageId,
     created_at: new Date().toISOString(),
     created_by: 'sdlab-training-package-v1',
@@ -134,7 +135,7 @@ export async function buildTrainingPackage(projectRoot, manifestId, options = {}
       val: partitions.val.length,
       test: partitions.test.length,
       images: totalImages,
-      checksums: checksumEntries.length,
+      checksums: 0, // updated after checksum pass below
     },
   };
   await writeFile(join(packageDir, 'manifest.json'), JSON.stringify(packageManifest, null, 2) + '\n');
@@ -143,6 +144,17 @@ export async function buildTrainingPackage(projectRoot, manifestId, options = {}
   const readme = generatePackageReadme(packageManifest, profile, manifest, adapterTarget);
   await writeFile(join(packageDir, 'README.md'), readme);
 
+  // Generate checksums AFTER manifest+README are on disk so they are included.
+  const checksumEntries = [];
+  const allFiles = await collectFiles(packageDir);
+  for (const filePath of allFiles.sort()) {
+    const relPath = relative(packageDir, filePath);
+    if (relPath === 'checksums.txt') continue;
+    const hash = await sha256File(filePath);
+    checksumEntries.push(`SHA256 (${relPath}) = ${hash}`);
+  }
+  await writeFile(join(packageDir, 'checksums.txt'), checksumEntries.join('\n') + '\n');
+
   return { packageId, records: totalRecords, images: totalImages };
 }
 
@@ -237,5 +249,7 @@ export async function loadTrainingPackage(projectRoot, packageId) {
   if (!existsSync(path)) {
     throw new Error(`Training package "${packageId}" not found at ${path}`);
   }
-  return JSON.parse(await readFile(path, 'utf-8'));
+  const manifest = JSON.parse(await readFile(path, 'utf-8'));
+  checkManifestVersion(manifest, 'training-package');
+  return manifest;
 }

package/lib/workflow-profiles.js

@@ -0,0 +1,161 @@
+/**
+ * Workflow profile management.
+ *
+ * A workflow profile is a production recipe — it defines how to generate
+ * a specific kind of output set (portrait pack, expression sheet, moodboard, etc.)
+ * using project canon and trained assets.
+ *
+ * Workflow profiles are NOT training profiles. They drive generation, not training.
+ */
+
+import { readFile, readdir, writeFile, mkdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { existsSync } from 'node:fs';
+import { getWorkflowProfilesDir } from './paths.js';
+
+const REQUIRED_FIELDS = [
+  'workflow_id', 'label', 'lane_id', 'output_mode', 'output_count',
+  'prompt_strategy', 'negative_strategy', 'canon_focus', 'drift_guards',
+  'runtime_defaults',
+];
+
+const VALID_SUBJECT_MODES = ['required', 'optional', 'forbidden'];
+
+const VALID_OUTPUT_MODES = [
+  'portrait_set', 'expression_sheet', 'variant_pack',
+  'moodboard', 'silhouette_sheet', 'turnaround',
+];
+
+const VALID_CANON_FOCUS = [
+  'silhouette', 'material_language', 'palette', 'anatomy',
+  'costume_logic', 'era_logic', 'scale_logic', 'lighting',
+  'surface_wear', 'gesture', 'composition', 'faction_read',
+];
+
+/**
+ * Validate a workflow profile object.
+ * @returns {{ valid: boolean, errors: string[] }}
+ */
+export function validateWorkflowProfile(profile) {
+  const errors = [];
+
+  for (const field of REQUIRED_FIELDS) {
+    if (profile[field] === undefined || profile[field] === null) {
+      errors.push(`missing required field: ${field}`);
+    }
+  }
+
+  if (profile.subject_mode && !VALID_SUBJECT_MODES.includes(profile.subject_mode)) {
+    errors.push(`invalid subject_mode "${profile.subject_mode}" — must be one of: ${VALID_SUBJECT_MODES.join(', ')}`);
+  }
+
+  if (profile.output_mode && !VALID_OUTPUT_MODES.includes(profile.output_mode)) {
+    errors.push(`invalid output_mode "${profile.output_mode}" — must be one of: ${VALID_OUTPUT_MODES.join(', ')}`);
+  }
+
+  if (!Number.isInteger(profile.output_count) || profile.output_count < 1) {
+    errors.push('output_count must be a positive integer');
+  }
+
+  // Prompt strategy structure
+  const ps = profile.prompt_strategy;
+  if (ps) {
+    if (!Array.isArray(ps.style_prefix)) errors.push('prompt_strategy.style_prefix must be an array');
+    if (typeof ps.structure !== 'string') errors.push('prompt_strategy.structure must be a string');
+    if (!Array.isArray(ps.must_include)) errors.push('prompt_strategy.must_include must be an array');
+  }
+
+  // Negative strategy structure
+  const ns = profile.negative_strategy;
+  if (ns) {
+    if (!Array.isArray(ns.must_avoid)) errors.push('negative_strategy.must_avoid must be an array');
+  }
+
+  // Canon focus items
+  if (Array.isArray(profile.canon_focus)) {
+    for (const item of profile.canon_focus) {
+      if (!VALID_CANON_FOCUS.includes(item)) {
+        errors.push(`invalid canon_focus item "${item}" — must be one of: ${VALID_CANON_FOCUS.join(', ')}`);
+      }
+    }
+  } else if (profile.canon_focus !== undefined) {
+    errors.push('canon_focus must be an array');
+  }
+
+  if (profile.drift_guards && !Array.isArray(profile.drift_guards)) {
+    errors.push('drift_guards must be an array');
+  }
+
+  // Runtime defaults
+  const rd = profile.runtime_defaults;
+  if (rd) {
+    if (!rd.adapter_target) errors.push('runtime_defaults.adapter_target is required');
+    if (rd.seed_mode && !['fixed', 'increment', 'random'].includes(rd.seed_mode)) {
+      errors.push(`invalid runtime_defaults.seed_mode "${rd.seed_mode}" — must be fixed, increment, or random`);
+    }
+  }
+
+  return { valid: errors.length === 0, errors };
+}
+
+/**
+ * Load a single workflow profile by ID.
+ */
+export async function getWorkflowProfile(projectRoot, workflowId) {
+  const dir = getWorkflowProfilesDir(projectRoot);
+  const path = join(dir, `${workflowId}.json`);
+  if (!existsSync(path)) {
+    throw new Error(`Workflow profile "${workflowId}" not found at ${path}`);
+  }
+  const data = JSON.parse(await readFile(path, 'utf-8'));
+  const { valid, errors } = validateWorkflowProfile(data);
+  if (!valid) {
+    throw new Error(`Workflow profile "${workflowId}" is invalid:\n  ${errors.join('\n  ')}`);
+  }
+  return data;
+}
+
+/**
+ * List all workflow profiles in a project.
+ */
+export async function listWorkflowProfiles(projectRoot) {
+  const dir = getWorkflowProfilesDir(projectRoot);
+  if (!existsSync(dir)) return [];
+
+  const files = (await readdir(dir)).filter(f => f.endsWith('.json')).sort();
+  const profiles = [];
+
+  for (const file of files) {
+    try {
+      const data = JSON.parse(await readFile(join(dir, file), 'utf-8'));
+      profiles.push({
+        workflow_id: data.workflow_id,
+        label: data.label,
+        lane_id: data.lane_id,
+        subject_mode: data.subject_mode || 'optional',
+        output_mode: data.output_mode,
+        output_count: data.output_count,
+      });
+    } catch {
+      // Skip malformed
+    }
+  }
+
+  return profiles;
+}
+
+/**
+ * Save a workflow profile to a project.
+ */
+export async function saveWorkflowProfile(projectRoot, profile) {
+  const { valid, errors } = validateWorkflowProfile(profile);
+  if (!valid) {
+    throw new Error(`Invalid workflow profile:\n  ${errors.join('\n  ')}`);
+  }
+  const dir = getWorkflowProfilesDir(projectRoot);
+  await mkdir(dir, { recursive: true });
+  await writeFile(
+    join(dir, `${profile.workflow_id}.json`),
+    JSON.stringify(profile, null, 2) + '\n'
+  );
+}

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "@mcptoolshop/style-dataset-lab",
-  "version": "2.3.0",
-  "description": "Visual canon and dataset production pipeline — snapshots, splits, versioned exports, eval packs, and canon-bound curation for any image production domain",
+  "version": "3.0.1",
+  "description": "Canon-aligned dataset production and generation workbench — define visual rules, build versioned training data, compile production briefs, run local workflows, batch-produce, select winners, and re-ingest into your corpus",
   "type": "module",
   "bin": {
     "sdlab": "./bin/sdlab.js"
   },
   "scripts": {
+    "test": "node --test tests/**/*.test.js",
     "verify": "node bin/sdlab.js --help && node bin/sdlab.js project doctor --project star-freight",
     "generate": "node scripts/generate.js",
     "curate": "node scripts/curate.js",
@@ -19,11 +20,16 @@
     "bin/",
     "lib/",
     "scripts/",
+    "!scripts/bulk-curate-*.js",
+    "!scripts/curate-wave*.js",
+    "!scripts/migrate-records.js",
     "templates/",
     "README.md",
     "LICENSE",
     "SECURITY.md",
-    "CHANGELOG.md"
+    "CHANGELOG.md",
+    "CONTRIBUTING.md",
+    "CODE_OF_CONDUCT.md"
   ],
   "keywords": [
     "dataset",
@@ -38,7 +44,10 @@
     "style-guide",
     "lora",
     "multimodal",
-    "comfyui"
+    "comfyui",
+    "generation-workflow",
+    "batch-production",
+    "reintegration"
   ],
   "homepage": "https://mcp-tool-shop-org.github.io/style-dataset-lab/",
   "repository": {