@mcptoolshop/style-dataset-lab 3.1.0 → 3.2.0

package/lib/freeze-gate.js

@@ -0,0 +1,165 @@
+/**
+ * Freeze enforcement gate (D3).
+ *
+ * Called from CLI commands before any write to a canon-bound asset or record.
+ * Semantics:
+ *   - frozen         → block outright (CANON_ENTRY_FROZEN)
+ *   - soft-advisory  → block unless --i-know + --reason; on override, append
+ *                      a 'bypass' event to freeze-events.jsonl and proceed
+ *   - auto           → no block
+ *   - on-canon-change → no block at write time; canon-build surfaces drift
+ *                      in its summary output (enforcement lives at the build
+ *                      boundary, not the CLI boundary, because drift is a
+ *                      build-observable condition)
+ *
+ * The canon reverse-map helpers resolve an action's identifier (subject id,
+ * asset path) to a canon entry so the gate can look up its freeze state.
+ * Actions without a canon binding (prompt-pack-driven generate, reingest of
+ * un-bound generated outputs) skip the gate naturally: no entry = nothing
+ * to protect.
+ */
+
+import { join } from 'node:path';
+import { existsSync } from 'node:fs';
+import { loadBuildConfig } from './canon-build/load-config.js';
+import { loadCanonEntriesInDir, entryId } from './canon-build/load-entry.js';
+import { readFreezeStatus } from './freeze-stamp.js';
+import { appendEvent } from './freeze-events.js';
+import { inputError } from './errors.js';
+
+/**
+ * Load every canon entry in a project, keyed by schema.
+ *
+ * Returns a flat array of `{ entry, schemaName }` objects.
+ * Returns [] (no-op) when the project has no canon-build config — meaning
+ * the project isn't canon-integrated yet, so the gate has nothing to enforce.
+ */
+export async function loadAllCanonEntries(projectRoot) {
+  const configPath = join(projectRoot, 'canon-build', 'config.json');
+  if (!existsSync(configPath)) return [];
+  let config;
+  try {
+    config = await loadBuildConfig(configPath, projectRoot);
+  } catch {
+    // Invalid config → degrade to "no gate" rather than blocking every write.
+    // The operator will hit the config error on `sdlab canon build`.
+    return [];
+  }
+  const entries = [];
+  for (const [schemaName, subdir] of Object.entries(config.entity_dirs)) {
+    const dir = join(config.canon_root, subdir);
+    const loaded = await loadCanonEntriesInDir(dir);
+    for (const entry of loaded) {
+      entries.push({ entry, schemaName });
+    }
+  }
+  return entries;
+}
+
+/**
+ * Find the canon entry whose `id` matches the given subject identifier.
+ * Returns { entry, schemaName } or null.
+ */
+export async function resolveEntryBySubject(projectRoot, subjectId) {
+  if (!subjectId) return null;
+  const all = await loadAllCanonEntries(projectRoot);
+  const hit = all.find(({ entry }) => entryId(entry) === subjectId);
+  return hit || null;
+}
+
+/**
+ * Find the canon entry whose `visual.reference_plate_uri` (or top-level
+ * `reference_plate_uri`, for monsters) equals the given asset path.
+ * Returns { entry, schemaName } or null.
+ */
+export async function resolveEntryByAssetPath(projectRoot, assetPath) {
+  if (!assetPath) return null;
+  const all = await loadAllCanonEntries(projectRoot);
+  const normalized = assetPath.replace(/\\/g, '/');
+  const hit = all.find(({ entry }) => {
+    const fm = entry.frontmatter;
+    const plate = (fm.visual?.reference_plate_uri || fm.reference_plate_uri || '').replace(/\\/g, '/');
+    return plate && plate === normalized;
+  });
+  return hit || null;
+}
+
+/**
+ * Core gate. Throws CANON_ENTRY_FROZEN on block; on soft-advisory bypass,
+ * appends a 'bypass' event and returns without throwing.
+ *
+ * @param {Object} args
+ * @param {string} args.projectRoot
+ * @param {Object|null} args.resolved — { entry, schemaName } or null
+ * @param {string} args.action — short verb for error context ("generate", "painterly", "curate", ...)
+ * @param {boolean} [args.allowSoftAdvisoryBypass] — the command supports --i-know
+ * @param {string} [args.bypassReason] — value of --reason when bypassing
+ * @param {string} [args.by] — who is invoking (default 'mike')
+ */
+export async function assertNotFrozen({
+  projectRoot,
+  resolved,
+  action,
+  allowSoftAdvisoryBypass = false,
+  bypassReason = null,
+  by = 'mike',
+}) {
+  if (!resolved || !resolved.entry) return; // nothing canon-bound; no gate
+  const fm = resolved.entry.frontmatter;
+  const status = readFreezeStatus(fm);
+  const id = entryId(resolved.entry);
+
+  if (status === 'frozen') {
+    throw inputError(
+      'CANON_ENTRY_FROZEN',
+      `Canon entry "${id}" is frozen; "${action}" refuses to proceed.`,
+      `Unfreeze with: sdlab canon unfreeze ${id} --reason "<why>". The override will be appended to canon-build/freeze-events.jsonl as an audit record.`,
+    );
+  }
+
+  if (status === 'soft-advisory') {
+    if (!allowSoftAdvisoryBypass) {
+      throw inputError(
+        'CANON_ENTRY_FROZEN',
+        `Canon entry "${id}" is soft-advisory frozen; "${action}" refuses to proceed.`,
+        `This command does not support a --i-know bypass. Run "sdlab canon unfreeze ${id} --reason \\"<why>\\"" for a proper unfreeze, or pick a command that accepts --i-know.`,
+      );
+    }
+    if (!bypassReason) {
+      throw inputError(
+        'CANON_ENTRY_FROZEN',
+        `Canon entry "${id}" is soft-advisory frozen; "${action}" requires --i-know AND --reason to bypass.`,
+        `Re-run with: --i-know --reason "<short reason>". The bypass will be logged to canon-build/freeze-events.jsonl.`,
+      );
+    }
+    // Bypass allowed — log and proceed.
+    await appendEvent(projectRoot, {
+      type: 'bypass',
+      entity_id: id,
+      schema_kind: resolved.schemaName?.replace('.schema.json', ''),
+      by,
+      reason: bypassReason,
+      prior_status: 'soft-advisory',
+      new_status: 'soft-advisory',
+    });
+    return;
+  }
+
+  // auto and on-canon-change: no write-side block.
+}
+
+/**
+ * Convenience wrapper: resolve by subject id, then gate.
+ */
+export async function assertNotFrozenBySubject(projectRoot, subjectId, options = {}) {
+  const resolved = await resolveEntryBySubject(projectRoot, subjectId);
+  return assertNotFrozen({ projectRoot, resolved, ...options });
+}
+
+/**
+ * Convenience wrapper: resolve by asset_path, then gate.
+ */
+export async function assertNotFrozenByAssetPath(projectRoot, assetPath, options = {}) {
+  const resolved = await resolveEntryByAssetPath(projectRoot, assetPath);
+  return assertNotFrozen({ projectRoot, resolved, ...options });
+}

package/lib/freeze-stamp.js

@@ -0,0 +1,161 @@
+/**
+ * Freeze block helpers — read/write the `freeze` block on a canon entry,
+ * compute watch-field hashes for the witness chain (D1).
+ *
+ * The `freeze` block (schema v2.0.0+) is the sole freeze surface on canon
+ * entries; the legacy `visual_locked_at` + `regen_policy` fields have been
+ * removed per post-research D10. See
+ * memory/freeze-tooling-research-2026-04-24.md for the full contract.
+ */
+
+import { createHash } from 'node:crypto';
+import { getByPath } from './canon-build/load-config.js';
+
+/**
+ * The four legal freeze statuses. Entries without a `freeze` block behave
+ * as `auto` (permissive default — see post-research D8).
+ */
+export const FREEZE_STATUSES = Object.freeze(['auto', 'frozen', 'soft-advisory', 'on-canon-change']);
+
+/**
+ * Read the normalized freeze status for an entry frontmatter.
+ * Missing block / missing status / invalid value all collapse to `auto`.
+ */
+export function readFreezeStatus(frontmatter) {
+  const status = frontmatter?.freeze?.status;
+  if (typeof status !== 'string') return 'auto';
+  if (!FREEZE_STATUSES.includes(status)) return 'auto';
+  return status;
+}
+
+/**
+ * Whether an entry's freeze status blocks a regen-like action outright.
+ * `frozen` blocks. `soft-advisory` blocks unless the caller overrides via
+ * --i-know + --reason. `auto` / `on-canon-change` do not block.
+ */
+export function freezeBlocksAction(status) {
+  return status === 'frozen';
+}
+
+/**
+ * Whether an entry's freeze status warrants a soft-advisory bypass path.
+ */
+export function freezeIsAdvisory(status) {
+  return status === 'soft-advisory';
+}
+
+/**
+ * Stable canonical JSON serialization for an object used as hash input.
+ *
+ * Sorts object keys; arrays preserve order (arrays are meaningful sequences).
+ * Normalizes `undefined` → omitted. Bit-stability matters because the witness
+ * chain compares hashes across builds — the same semantic value must hash
+ * identically regardless of key insertion order or JSON formatting drift.
+ */
+export function canonicalize(value) {
+  if (value === null) return 'null';
+  if (value === undefined) return 'null';
+  if (typeof value === 'number') return Number.isFinite(value) ? String(value) : 'null';
+  if (typeof value === 'boolean') return value ? 'true' : 'false';
+  if (typeof value === 'string') return JSON.stringify(value);
+  if (Array.isArray(value)) {
+    return '[' + value.map(canonicalize).join(',') + ']';
+  }
+  if (typeof value === 'object') {
+    const keys = Object.keys(value).sort();
+    const parts = [];
+    for (const k of keys) {
+      if (value[k] === undefined) continue;
+      parts.push(JSON.stringify(k) + ':' + canonicalize(value[k]));
+    }
+    return '{' + parts.join(',') + '}';
+  }
+  return 'null';
+}
+
+/**
+ * Compute the watch-hash for an entry given its frontmatter, the list of
+ * watched fields, and the schema version.
+ *
+ * The hash is sha256 of a canonical JSON representation of the watched
+ * field values + the schema version. Any change to a watched field, or a
+ * schema version bump, invalidates the hash.
+ *
+ * @param {Object} frontmatter — entry frontmatter object
+ * @param {Array<string>} watchFields — dotted paths (e.g. "visual.silhouette_cue")
+ * @param {string} schemaVersion — schema `version` string
+ * @returns {string} 64-char hex sha256 digest
+ */
+export function computeWatchHash(frontmatter, watchFields, schemaVersion) {
+  const payload = {
+    schema_version: schemaVersion,
+    watched: {},
+  };
+  for (const field of watchFields) {
+    payload.watched[field] = getByPath(frontmatter, field) ?? null;
+  }
+  return createHash('sha256').update(canonicalize(payload)).digest('hex');
+}
+
+/**
+ * Resolve the effective watch-field list for an entry.
+ *
+ * Precedence (entry override wins over build-config default):
+ *   1. `frontmatter.freeze.watch_fields` if present + non-empty
+ *   2. `buildConfig.freeze_watch_defaults[schemaName]` if present
+ *   3. [] (empty — a freeze with no watch-fields stamps only the schema
+ *      version, useful for "freeze but don't drift-check" intent)
+ */
+export function resolveWatchFields(frontmatter, schemaName, buildConfig) {
+  const entryOverride = frontmatter?.freeze?.watch_fields;
+  if (Array.isArray(entryOverride) && entryOverride.length > 0) {
+    return entryOverride;
+  }
+  const defaults = buildConfig?.freeze_watch_defaults?.[schemaName];
+  if (Array.isArray(defaults) && defaults.length > 0) {
+    return defaults;
+  }
+  return [];
+}
+
+/**
+ * Build a fresh freeze block for writing to an entry (canon freeze command).
+ *
+ * @param {Object} args
+ * @param {string} args.status — 'frozen' | 'soft-advisory' | 'on-canon-change'
+ * @param {string} args.lockedAtBuild — generated_from of the witness build
+ * @param {string} [args.lockedAtCanonVersion]
+ * @param {string} args.frozenBy
+ * @param {string} args.frozenReason
+ * @param {Array<string>} [args.watchFields]
+ * @param {Array} [args.overrides] — existing override history (preserved on re-freeze)
+ */
+export function buildFreezeBlock({
+  status,
+  lockedAtBuild,
+  lockedAtCanonVersion,
+  frozenBy,
+  frozenReason,
+  watchFields,
+  overrides,
+}) {
+  const block = { status };
+  if (lockedAtBuild) block.locked_at_build = lockedAtBuild;
+  if (lockedAtCanonVersion) block.locked_at_canon_version = lockedAtCanonVersion;
+  if (frozenBy) block.frozen_by = frozenBy;
+  if (frozenReason) block.frozen_reason = frozenReason;
+  if (Array.isArray(watchFields) && watchFields.length) block.watch_fields = watchFields;
+  if (Array.isArray(overrides) && overrides.length) block.overrides = overrides;
+  return block;
+}
+
+/**
+ * Append an override record to an entry's freeze.overrides[] list.
+ * Denormalizes the event into the entry for glance-reading; the authoritative
+ * source of truth is the append-only log at canon-build/freeze-events.jsonl.
+ */
+export function appendOverrideToFreezeBlock(freeze, override) {
+  const next = { ...freeze };
+  next.overrides = Array.isArray(freeze?.overrides) ? [...freeze.overrides, override] : [override];
+  return next;
+}

package/lib/rows.js

@@ -0,0 +1,228 @@
+/**
+ * Canonical dataset row shape.
+ *
+ * The single source-of-truth shape that adapters (generic-image-caption,
+ * diffusers-lora, ai-toolkit) consume. Two producers feed this shape:
+ *
+ *   1. `canon-build` — emits rows to disk at
+ *      `<project>/canon-build/<canon_sha>/dataset/<lane>-<partition>.jsonl`
+ *      from the canon entity store (research D1, D2).
+ *   2. `training-packages` — converts legacy records-path `{record, lane, group}`
+ *      entries into rows in memory so the records flow keeps working while
+ *      canon authoring catches up.
+ *
+ * Both paths produce rows the adapter cannot distinguish. This is D6:
+ * adapters have one input contract, not two.
+ *
+ * The research deliverable pins the row schema. See
+ * `memory/three-projection-build-research-2026-04-24.md` §Projection contracts.
+ */
+
+import { readFile } from 'node:fs/promises';
+import { createHash } from 'node:crypto';
+import { buildCaption, deriveStyleTrigger } from './captions.js';
+
+export const ROW_SCHEMA_VERSION = 'canon-build-dataset-1.0';
+
+/**
+ * Compute SHA-256 of a deterministic serialization of the inputs.
+ * Used for `entry_hash` (cache key) when building rows from canon entries.
+ */
+export function hashRowInputs({ entryBody, schemaVersion, buildConfigJson, projectFingerprint }) {
+  const h = createHash('sha256');
+  h.update(entryBody || '');
+  h.update('\0');
+  h.update(schemaVersion || '');
+  h.update('\0');
+  h.update(buildConfigJson || '');
+  h.update('\0');
+  h.update(projectFingerprint || '');
+  return h.digest('hex');
+}
+
+/**
+ * Build a row from a legacy record object.
+ *
+ * The records flow (star-freight today) produces `{ record, lane, group }`
+ * tuples via split + snapshot + canon-binding. Each tuple becomes one row.
+ *
+ * @param {Object} record — the records/<id>.json object
+ * @param {string|null} lane — resolved lane (costume, environment, ...)
+ * @param {string|null} group — resolved group (faction, region, ...)
+ * @param {Object} profile — training profile (for caption + trigger)
+ * @param {string} partition — train | val | test
+ * @returns {Object|null} row, or null if the record has no asset_path
+ */
+export function recordToRow(record, lane, group, profile, partition) {
+  if (!record?.id || !record.asset_path) return null;
+
+  const trigger = deriveStyleTrigger(profile) || null;
+  const caption = buildCaption(record, lane, group, profile);
+
+  const row = {
+    schema_version: ROW_SCHEMA_VERSION,
+    generated_from: null,               // records path: no canon commit
+    entity_id: record.id,
+    schema_kind: 'record',              // legacy marker: not a canon entity
+    entity_type: record.identity?.kind || null,
+    lane,
+    partition,
+    asset_path: record.asset_path,
+    caption,
+    trigger,
+    subject_filter_key: record.identity?.subject_name || record.id,
+    forbidden_tokens: record.canon?.forbidden_inputs || [],
+    pass_ratio: record.canon?.assertion_count > 0
+      ? +(record.canon.pass_count / record.canon.assertion_count).toFixed(3)
+      : null,
+    group,
+  };
+
+  return row;
+}
+
+/**
+ * Build a row from a canon entity + approved reference plate.
+ *
+ * The canon-build flow produces rows from canon entries. Each entry may
+ * contribute one or more rows (one per approved reference plate × lane).
+ *
+ * @param {Object} args
+ * @param {Object} args.entry — parsed canon entry (frontmatter object)
+ * @param {string} args.schemaKind — monster | character | deity | location | relic
+ * @param {string} args.assetPath — project-relative path to the approved plate
+ * @param {string} args.lane — resolved lane
+ * @param {string} args.caption — pre-rendered via buildCaption
+ * @param {string|null} args.trigger — from the training profile that drove the plate
+ * @param {string} args.partition — train | val | test (canon-build defaults to train)
+ * @param {string} args.entryHash — SHA-256 of entry + schema_version + build_config + project_fingerprint
+ * @param {string|null} args.generatedFrom — canon commit SHA or "content-sha:..." fallback
+ */
+export function canonEntryToRow({
+  entry,
+  schemaKind,
+  assetPath,
+  lane,
+  caption,
+  trigger,
+  partition,
+  entryHash,
+  generatedFrom,
+}) {
+  const entityType = entry.kind
+    || entry.species_tag
+    || entry.location_type
+    || entry.relic_type
+    || entry.generation
+    || null;
+
+  return {
+    schema_version: ROW_SCHEMA_VERSION,
+    generated_from: generatedFrom,
+    entity_id: entry.id,
+    schema_kind: schemaKind,
+    entity_type: entityType,
+    lane,
+    partition,
+    asset_path: assetPath,
+    caption,
+    trigger,
+    subject_filter_key: entry.id,
+    forbidden_tokens: entry.forbidden_inputs || [],
+    entry_hash: entryHash,
+  };
+}
+
+/**
+ * Read rows from a dataset.jsonl file.
+ *
+ * Parses each non-empty line as JSON; rejects the file if any row's
+ * `schema_version` does not match ROW_SCHEMA_VERSION.
+ *
+ * @param {string} path — absolute path to dataset.jsonl
+ * @returns {Promise<Array<Object>>} rows
+ */
+export async function readDatasetJsonl(path) {
+  const text = await readFile(path, 'utf-8');
+  const rows = [];
+  const lines = text.split('\n');
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i].trim();
+    if (!line) continue;
+    let row;
+    try {
+      row = JSON.parse(line);
+    } catch (err) {
+      throw new Error(`readDatasetJsonl: line ${i + 1} of ${path} is not valid JSON (${err.message})`);
+    }
+    if (row.schema_version !== ROW_SCHEMA_VERSION) {
+      throw new Error(
+        `readDatasetJsonl: line ${i + 1} of ${path} has schema_version "${row.schema_version}" (expected "${ROW_SCHEMA_VERSION}")`
+      );
+    }
+    rows.push(row);
+  }
+  return rows;
+}
+
+/**
+ * Group rows by partition (train | val | test).
+ * Rows with missing/unknown partition are grouped under an "other" key.
+ */
+export function groupRowsByPartition(rows) {
+  const out = { train: [], val: [], test: [] };
+  for (const row of rows) {
+    const p = row.partition || 'other';
+    if (!out[p]) out[p] = [];
+    out[p].push(row);
+  }
+  return out;
+}
+
+/**
+ * Filter rows for a training profile.
+ *
+ * Two filter axes:
+ *   - lane-based: include row if row.lane ∈ profile.eligible_lanes
+ *   - entity-based: include row if row.entity_id === profile.entity_id_scope
+ *     (when entity_id_scope is set — per-character LoRA case, D8)
+ *
+ * Both filters compose: a per-character profile with both eligible_lanes and
+ * entity_id_scope set applies both as AND. Zero filters = pass everything.
+ */
+export function filterRowsForProfile(rows, profile) {
+  const eligibleLanes = profile.eligible_lanes;
+  const entityScope = profile.entity_id_scope;
+
+  return rows.filter((row) => {
+    if (Array.isArray(eligibleLanes) && eligibleLanes.length > 0) {
+      if (!eligibleLanes.includes(row.lane)) return false;
+    }
+    if (entityScope) {
+      if (row.entity_id !== entityScope && row.subject_filter_key !== entityScope) {
+        return false;
+      }
+    }
+    return true;
+  });
+}
+
+/**
+ * Serialize a row to a stable JSONL line.
+ * Key order is enforced by emitting known fields first, then alphabetized extras.
+ */
+export function serializeRow(row) {
+  const knownOrder = [
+    'schema_version', 'generated_from', 'entity_id', 'schema_kind', 'entity_type',
+    'lane', 'partition', 'asset_path', 'caption', 'trigger',
+    'subject_filter_key', 'forbidden_tokens', 'entry_hash', 'pass_ratio', 'group',
+  ];
+  const ordered = {};
+  for (const key of knownOrder) {
+    if (row[key] !== undefined) ordered[key] = row[key];
+  }
+  for (const key of Object.keys(row).sort()) {
+    if (!knownOrder.includes(key)) ordered[key] = row[key];
+  }
+  return JSON.stringify(ordered);
+}

package/lib/training-adapters.js

@@ -27,6 +27,11 @@ export const ADAPTER_REGISTRY = Object.freeze({
     description: 'Diffusers fine-tuning layout: image + caption .txt sidecars + per-partition JSONL',
     module: './adapters/diffusers-lora.js',
   },
+  'ai-toolkit': {
+    id: 'ai-toolkit',
+    description: 'Ostris ai-toolkit Flux training package: image + .txt sidecars + ai-toolkit-config.yaml at root',
+    module: './adapters/ai-toolkit.js',
+  },
 });
 
 /**

package/lib/training-packages.js

@@ -18,6 +18,7 @@ import { loadProjectConfig, detectLane, detectGroup } from './config.js';
 import { inputError } from './errors.js';
 import { SCHEMA_VERSION, checkManifestVersion } from './snapshot.js';
 import { loadAdapter } from './training-adapters.js';
+import { recordToRow, filterRowsForProfile } from './rows.js';
 
 /**
  * Generate a training package ID: tp-YYYYMMDD-HHMMSS-XXXX
@@ -61,38 +62,43 @@ export async function buildTrainingPackage(projectRoot, manifestId, options = {}
     );
   }
 
-  // Load split partitions
-  const partitions = {};
-  let totalRecords = 0;
-  let totalImages = 0;
+  // Convert split partitions → canonical rows (D6 adapter input shape).
+  // Adapters only understand rows — records-flow callers go through this
+  // converter, canon-build-flow callers produce rows directly. One input
+  // contract, two producers.
+  const rows = [];
+  const partitionCounts = { train: 0, val: 0, test: 0 };
 
   for (const partition of ['train', 'val', 'test']) {
     const entries = await loadSplitPartition(projectRoot, manifest.source_split_id, partition);
-    const records = [];
 
     for (const entry of entries) {
       const record = await loadRecord(recordsDir, entry.record_id);
       if (!record) continue;
 
-      // Filter by profile's eligible lanes
       const prompt = record.provenance?.prompt || '';
       const lane = detectLane(record.id, prompt, config.lanes);
-      if (profile.eligible_lanes.length > 0 && !profile.eligible_lanes.includes(lane)) {
-        continue;
-      }
-
       const group = detectGroup(record.id, prompt, config.terminology);
-      records.push({ record, lane, group });
+
+      const row = recordToRow(record, lane, group, profile, partition);
+      if (row) rows.push(row);
     }
+  }
 
-    partitions[partition] = records;
-    totalRecords += records.length;
+  // Apply profile filters (eligible_lanes + entity_id_scope — D8).
+  // filterRowsForProfile returns rows where lane ∈ eligible_lanes AND
+  // entity_id === entity_id_scope (when set). Zero filters = identity.
+  const filteredRows = filterRowsForProfile(rows, profile);
+  for (const row of filteredRows) {
+    if (partitionCounts[row.partition] !== undefined) partitionCounts[row.partition]++;
   }
+  const totalRecords = filteredRows.length;
+  let totalImages = 0;
 
-  // Let the adapter build the package layout
+  // Let the adapter build the package layout from the canonical rows.
   const adapterResult = await adapter.buildPackage({
     packageDir,
-    partitions,
+    rows: filteredRows,
     profile,
     manifest,
     config,
@@ -118,9 +124,9 @@ export async function buildTrainingPackage(projectRoot, manifestId, options = {}
     config_fingerprint: manifest.config_fingerprint,
     counts: {
       total_records: totalRecords,
-      train: partitions.train.length,
-      val: partitions.val.length,
-      test: partitions.test.length,
+      train: partitionCounts.train,
+      val: partitionCounts.val,
+      test: partitionCounts.test,
       images: totalImages,
       checksums: 0, // updated after checksum pass below
     },

package/lib/training-profiles.js

@@ -13,6 +13,13 @@ import { isRegisteredAdapter, listAdapters } from './training-adapters.js';
 
 const REQUIRED_FIELDS = ['profile_id', 'label', 'target_family', 'asset_type', 'eligible_lanes', 'adapter_targets'];
 
+// trigger_override constraints (research ref: two-LoRA stack D3, 2026-04-24).
+// T5 tokenizes on SentencePiece Unigram with `_` as the space sentinel; hyphens
+// fragment unpredictably and uppercase is not canonicalized. Generic suffixes
+// alone collide across projects — a game-slug prefix is the documented defense.
+const TRIGGER_OVERRIDE_RE = /^[a-z0-9_]+$/;
+const TRIGGER_GENERIC_SUFFIX_DENYLIST = ['style', 'character', 'anime', 'realistic'];
+
 /**
  * Validate a training profile object.
  * @returns {{ valid: boolean, errors: string[] }}
@@ -42,6 +49,32 @@ export function validateProfile(profile) {
       }
     }
   }
+  // trigger_override is optional. When present, enforce SentencePiece-safe
+  // format and reject bare generic suffixes that collide across projects.
+  if (profile.trigger_override !== undefined && profile.trigger_override !== null) {
+    if (typeof profile.trigger_override !== 'string') {
+      errors.push('trigger_override must be a string');
+    } else if (profile.trigger_override.length === 0) {
+      errors.push('trigger_override must be a non-empty string (or omit the field)');
+    } else if (!TRIGGER_OVERRIDE_RE.test(profile.trigger_override)) {
+      errors.push(`trigger_override "${profile.trigger_override}" must match ^[a-z0-9_]+$ (lowercase, digits, underscores — no hyphens, no uppercase)`);
+    } else if (TRIGGER_GENERIC_SUFFIX_DENYLIST.includes(profile.trigger_override)) {
+      errors.push(`trigger_override "${profile.trigger_override}" is a generic suffix; prefix with a game slug (e.g. "sf_${profile.trigger_override}")`);
+    }
+  }
+  // entity_id_scope is optional (post-research D8). Same SentencePiece-safe
+  // format as trigger_override — no hyphens, no uppercase, lowercase slug.
+  // Used by per-character LoRA profiles to row-filter canonical dataset.jsonl
+  // to a single subject at packaging time.
+  if (profile.entity_id_scope !== undefined && profile.entity_id_scope !== null) {
+    if (typeof profile.entity_id_scope !== 'string') {
+      errors.push('entity_id_scope must be a string');
+    } else if (profile.entity_id_scope.length === 0) {
+      errors.push('entity_id_scope must be a non-empty string (or omit the field)');
+    } else if (!TRIGGER_OVERRIDE_RE.test(profile.entity_id_scope)) {
+      errors.push(`entity_id_scope "${profile.entity_id_scope}" must match ^[a-z0-9_]+$ (lowercase, digits, underscores — no hyphens, no uppercase)`);
+    }
+  }
   return { valid: errors.length === 0, errors };
 }