@mcptoolshop/style-dataset-lab 2.3.0 → 3.0.1

package/lib/eval-pack.js

@@ -16,6 +16,8 @@ import { existsSync } from 'node:fs';
 import { randomBytes } from 'node:crypto';
 import { loadProjectConfig, detectLane, detectGroup } from './config.js';
 import { loadRecord } from './records.js';
+import { computeConfigFingerprint, SCHEMA_VERSION, checkManifestVersion } from './snapshot.js';
+import { inputError } from './errors.js';
 
 /**
  * Generate an eval-pack ID: eval-YYYYMMDD-HHMMSS-XXXX
@@ -44,11 +46,18 @@ export async function buildEvalPack(projectRoot, options = {}) {
   const maxDrift = options.maxDrift || 20;
   const maxContinuity = options.maxContinuity || 10;
 
-  // Load all records
+  // Load all records (DB-003-adjacent: skip unparseable files rather than
+  // aborting the entire eval-pack build — same graceful-degradation shape
+  // snapshot.js uses).
   const records = [];
   for (const file of files) {
-    const record = JSON.parse(await readFile(join(recordsDir, file), 'utf-8'));
-    records.push(record);
+    try {
+      const record = JSON.parse(await readFile(join(recordsDir, file), 'utf-8'));
+      records.push(record);
+    } catch {
+      // Skip unreadable records; eval pack is a best-effort selection and
+      // one bad file must not kill the whole build.
+    }
   }
 
   // Task 1: Lane coverage
@@ -66,19 +75,60 @@ export async function buildEvalPack(projectRoot, options = {}) {
   // Write eval pack
   const evalId = generateEvalId();
   const evalDir = join(projectRoot, 'eval-packs', evalId);
+  // D-005: refuse to silently overwrite on ID collision.
+  if (existsSync(evalDir)) {
+    throw inputError(
+      'EVAL_PACK_ID_COLLISION',
+      `Eval pack directory already exists: ${evalDir}`,
+      'Retry to generate a fresh eval pack ID.',
+    );
+  }
   await mkdir(evalDir, { recursive: true });
 
+  // DB-014: compute `records_available` so the manifest reports sampled vs.
+  // available. Operators can see when they're leaving records on the table.
+  const laneAvailable = countLaneCoverageCandidates(records, config);
+  const driftAvailable = countForbiddenDriftCandidates(records);
+  const anchorAvailable = countAnchorGoldCandidates(records, config);
+  const continuityAvailable = countSubjectContinuityCandidates(records);
+
   const manifest = {
+    // DB-001 / DB-006: stamp manifest schema version
+    schema_version: SCHEMA_VERSION,
     eval_id: evalId,
     created_at: new Date().toISOString(),
     created_by: 'sdlab-eval-v1',
     project: config.meta.name,
+    // D-017: capture config fingerprint so eval verdicts can detect canon drift.
+    config_fingerprint: computeConfigFingerprint(projectRoot),
     task_counts: {
       lane_coverage: laneCoverage.length,
       forbidden_drift: forbiddenDrift.length,
       anchor_gold: anchorGold.length,
       subject_continuity: subjectContinuity.length,
     },
+    // DB-014: coverage — sampled vs. available per task
+    records_sampled: {
+      lane_coverage: laneCoverage.length,
+      forbidden_drift: forbiddenDrift.length,
+      anchor_gold: anchorGold.length,
+      subject_continuity: subjectContinuity.length,
+      total: laneCoverage.length + forbiddenDrift.length +
+        anchorGold.length + subjectContinuity.length,
+    },
+    records_available: {
+      lane_coverage: laneAvailable,
+      forbidden_drift: driftAvailable,
+      anchor_gold: anchorAvailable,
+      subject_continuity: continuityAvailable,
+      total: laneAvailable + driftAvailable + anchorAvailable + continuityAvailable,
+    },
+    caps: {
+      max_per_lane: maxPerLane,
+      max_per_faction: maxPerFaction,
+      max_drift: maxDrift,
+      max_continuity: maxContinuity,
+    },
     total_records: laneCoverage.length + forbiddenDrift.length +
       anchorGold.length + subjectContinuity.length,
   };
@@ -95,6 +145,44 @@ export async function buildEvalPack(projectRoot, options = {}) {
   };
 }
 
+/** DB-014: count approved+canon-bound records (the lane-coverage candidate pool). */
+function countLaneCoverageCandidates(records, _config) {
+  let n = 0;
+  for (const r of records) {
+    if (r.judgment?.status === 'approved' && r.canon?.assertions?.length) n++;
+  }
+  return n;
+}
+
+/** DB-014: count records that qualify as forbidden-drift candidates. */
+function countForbiddenDriftCandidates(records) {
+  let n = 0;
+  for (const r of records) {
+    const status = r.judgment?.status;
+    if (status !== 'rejected' && status !== 'borderline') continue;
+    const failureModes = r.judgment?.failure_modes || [];
+    const failedAssertions = (r.canon?.assertions || [])
+      .filter(a => a.verdict === 'fail').length;
+    if (failureModes.length > 0 || failedAssertions > 0 || r.judgment?.explanation) n++;
+  }
+  return n;
+}
+
+/** DB-014: count approved+canon-bound records (also anchor-gold pool). */
+function countAnchorGoldCandidates(records, _config) {
+  return countLaneCoverageCandidates(records, _config);
+}
+
+/** DB-014: count named subjects (subject-continuity pool). */
+function countSubjectContinuityCandidates(records) {
+  const subjects = new Set();
+  for (const r of records) {
+    const s = r.identity?.subject_name;
+    if (s) subjects.add(s);
+  }
+  return subjects.size;
+}
+
 /**
  * Task 1: Lane coverage — best approved record per lane.
  */
@@ -279,5 +367,7 @@ export async function loadEvalPack(projectRoot, evalId) {
   if (!existsSync(path)) {
     throw new Error(`Eval pack "${evalId}" not found at ${path}`);
   }
-  return JSON.parse(await readFile(path, 'utf-8'));
+  const manifest = JSON.parse(await readFile(path, 'utf-8'));
+  checkManifestVersion(manifest, 'eval-pack');
+  return manifest;
 }

package/lib/eval-runs.js

@@ -13,6 +13,11 @@ import { randomBytes } from 'node:crypto';
 import { loadTrainingManifest } from './training-manifests.js';
 import { loadEvalPack } from './eval-pack.js';
 import { loadProjectConfig, detectLane, detectGroup } from './config.js';
+import { SCHEMA_VERSION, checkManifestVersion } from './snapshot.js';
+
+// DB-008: cap sample record_ids per failure bucket so scorecards stay small
+// but the operator has enough detail to start investigation.
+const SAMPLE_LIMIT = 5;
 
 /**
  * Generate an eval run ID: er-YYYYMMDD-HHMMSS-XXXX
@@ -42,6 +47,8 @@ export async function createEvalRun(projectRoot, manifestId, evalPackId) {
   await mkdir(evalRunDir, { recursive: true });
 
   const runManifest = {
+    // DB-001 / DB-006: stamp manifest schema version
+    schema_version: SCHEMA_VERSION,
     eval_run_id: evalRunId,
     created_at: new Date().toISOString(),
     created_by: 'sdlab-eval-run-v1',
@@ -148,16 +155,25 @@ export async function scoreEvalRun(projectRoot, evalRunId, outputsPath) {
 function scoreLaneCoverage(tasks, outputMap) {
   let covered = 0;
   const lanes = new Set();
+  // DB-008: collect record_ids that missed coverage so the operator can drill
+  // down from "covered: 7/10" to "which 3 weren't covered".
+  const missedSamples = [];
   for (const task of tasks) {
     lanes.add(task.lane);
     const output = outputMap.get(task.record_id);
-    if (output?.accept) covered++;
+    if (output?.accept) {
+      covered++;
+    } else if (missedSamples.length < SAMPLE_LIMIT) {
+      missedSamples.push(task.record_id);
+    }
   }
   const score = tasks.length > 0 ? covered / tasks.length : 0;
   return {
     task: 'lane_coverage',
     total: tasks.length,
     covered,
+    missed: tasks.length - covered,
+    missed_sample_record_ids: missedSamples,
     lanes_represented: lanes.size,
     score: +score.toFixed(3),
     passed: score >= 0.7,
@@ -168,12 +184,19 @@ function scoreForbiddenDrift(tasks, outputMap) {
   // For forbidden drift, we check that rejected/borderline records are NOT accepted
   let correctRejections = 0;
   let falseAcceptances = 0;
+  // DB-008: name the records that were wrongly accepted. Without this, a
+  // scorecard that says "false_acceptances: 3" forces the operator to diff
+  // outputs.jsonl against the eval pack manually.
+  const falseAcceptanceSamples = [];
   for (const task of tasks) {
     const output = outputMap.get(task.record_id);
     if (!output || !output.accept) {
       correctRejections++;
     } else {
       falseAcceptances++;
+      if (falseAcceptanceSamples.length < SAMPLE_LIMIT) {
+        falseAcceptanceSamples.push(task.record_id);
+      }
     }
   }
   const score = tasks.length > 0 ? correctRejections / tasks.length : 1;
@@ -182,6 +205,7 @@ function scoreForbiddenDrift(tasks, outputMap) {
     total: tasks.length,
     correct_rejections: correctRejections,
     false_acceptances: falseAcceptances,
+    false_acceptance_sample_record_ids: falseAcceptanceSamples,
     score: +score.toFixed(3),
     passed: falseAcceptances === 0,
   };
@@ -189,15 +213,23 @@ function scoreForbiddenDrift(tasks, outputMap) {
 
 function scoreAnchorGold(tasks, outputMap) {
   let matched = 0;
+  // DB-008: which anchor records failed to match?
+  const missedSamples = [];
   for (const task of tasks) {
     const output = outputMap.get(task.record_id);
-    if (output?.accept) matched++;
+    if (output?.accept) {
+      matched++;
+    } else if (missedSamples.length < SAMPLE_LIMIT) {
+      missedSamples.push(task.record_id);
+    }
   }
   const score = tasks.length > 0 ? matched / tasks.length : 0;
   return {
     task: 'anchor_gold',
     total: tasks.length,
     matched,
+    missed: tasks.length - matched,
+    missed_sample_record_ids: missedSamples,
     score: +score.toFixed(3),
     passed: score >= 0.8,
   };
@@ -205,16 +237,23 @@ function scoreAnchorGold(tasks, outputMap) {
 
 function scoreSubjectContinuity(tasks, outputMap) {
   let subjectsWithCoverage = 0;
+  // DB-008: which named subjects lost continuity coverage?
+  const missedSamples = [];
   for (const task of tasks) {
     const recordIds = task.record_ids || [];
     const accepted = recordIds.filter(id => outputMap.get(id)?.accept).length;
-    if (accepted >= 2) subjectsWithCoverage++;
+    if (accepted >= 2) {
+      subjectsWithCoverage++;
+    } else if (missedSamples.length < SAMPLE_LIMIT) {
+      missedSamples.push(task.subject_name || recordIds[0] || 'unknown');
+    }
   }
   const score = tasks.length > 0 ? subjectsWithCoverage / tasks.length : 0;
   return {
     task: 'subject_continuity',
     total_subjects: tasks.length,
     subjects_with_coverage: subjectsWithCoverage,
+    missed_subject_samples: missedSamples,
     score: +score.toFixed(3),
     passed: score >= 0.6,
   };

package/lib/export.js

@@ -6,14 +6,17 @@
  */
 
 import { readFile, writeFile, mkdir, readdir, symlink, copyFile, stat } from 'node:fs/promises';
-import { join, relative, resolve } from 'node:path';
+import { join, relative, resolve, sep, basename, isAbsolute } from 'node:path';
 import { existsSync } from 'node:fs';
+import { platform } from 'node:os';
 import { createHash, randomBytes } from 'node:crypto';
 import { loadProjectConfig, loadExportProfile, detectLane, detectGroup } from './config.js';
-import { loadSnapshot, loadSnapshotIncluded, computeConfigFingerprint } from './snapshot.js';
+import { loadSnapshot, loadSnapshotIncluded, computeConfigFingerprint, SCHEMA_VERSION, checkManifestVersion } from './snapshot.js';
 import { loadSplit, loadSplitPartition } from './split.js';
 import { loadRecord } from './records.js';
 import { generateCard } from './card.js';
+import { inputError } from './errors.js';
+import { warn } from './log.js';
 
 /**
  * Generate an export ID: export-YYYYMMDD-HHMMSS-XXXX
@@ -54,6 +57,29 @@ export async function buildExport(projectRoot, snapshotId, splitId, options = {}
 
   const exportId = generateExportId();
   const exportDir = join(projectRoot, 'exports', exportId);
+
+  // D-005: existsSync guard prevents silent overwrite on ID collision
+  if (existsSync(exportDir)) {
+    throw inputError(
+      'EXPORT_ID_COLLISION',
+      `Export directory already exists: ${exportDir}`,
+      'Retry to generate a fresh export ID, or delete the existing directory if this was intentional.',
+    );
+  }
+
+  // D-001: Verify fingerprint has not drifted since snapshot creation.
+  // We inherit the snapshot's fingerprint in the export manifest; if a caller
+  // has edited project config mid-flight we surface that loudly rather than
+  // silently embedding a new fingerprint that masks reproducibility loss.
+  const currentFingerprint = computeConfigFingerprint(projectRoot);
+  if (snapshot.config_fingerprint && currentFingerprint !== snapshot.config_fingerprint) {
+    throw inputError(
+      'FINGERPRINT_DRIFT',
+      `Project config fingerprint has changed since snapshot "${snapshotId}" was created.`,
+      `Snapshot fingerprint: ${snapshot.config_fingerprint.slice(0, 16)}..., current: ${currentFingerprint.slice(0, 16)}.... Create a fresh snapshot from the updated config, or revert the config edits.`,
+    );
+  }
+
   await mkdir(exportDir, { recursive: true });
 
   // Build metadata + collect image paths
@@ -61,6 +87,8 @@ export async function buildExport(projectRoot, snapshotId, splitId, options = {}
   const imagePaths = [];
   const checksumEntries = [];
 
+  const projectRootResolved = resolve(projectRoot);
+
   for (const entry of included) {
     const record = await loadRecord(recordsDir, entry.record_id);
     if (!record) continue;
@@ -87,10 +115,33 @@ export async function buildExport(projectRoot, snapshotId, splitId, options = {}
 
     // Track image for linking
     if (profile.include_images && record.asset_path) {
+      // D-007: validate asset_path does not escape projectRoot, use
+      // platform-safe basename, and name output files by record.id
+      // (D-009) to avoid collisions on shared basenames.
+      if (isAbsolute(record.asset_path)) {
+        throw inputError(
+          'ASSET_PATH_INVALID',
+          `Record "${record.id}" has absolute asset_path: ${record.asset_path}`,
+          'asset_path must be relative to the project root.',
+        );
+      }
+      const resolvedSource = resolve(projectRootResolved, record.asset_path);
+      if (resolvedSource !== projectRootResolved &&
+          !resolvedSource.startsWith(projectRootResolved + sep)) {
+        throw inputError(
+          'ASSET_PATH_TRAVERSAL',
+          `Record "${record.id}" asset_path escapes projectRoot: ${record.asset_path}`,
+          'Reject path traversal segments (e.g. "../") in asset_path.',
+        );
+      }
+      const sourceBasename = basename(record.asset_path);
+      const extMatch = sourceBasename.match(/\.[^.]+$/);
+      const ext = extMatch ? extMatch[0] : '';
+      const safeFilename = `${record.id}${ext}`;
       imagePaths.push({
         record_id: record.id,
-        source: join(projectRoot, record.asset_path),
-        filename: record.asset_path.split('/').pop(),
+        source: resolvedSource,
+        filename: safeFilename,
       });
     }
   }
@@ -100,27 +151,70 @@ export async function buildExport(projectRoot, snapshotId, splitId, options = {}
   await writeFile(metadataPath, metadata.map(r => JSON.stringify(r)).join('\n') + '\n');
 
   // Images directory
+  const warnings = [];
+  // DB-002: separate accounting for expected vs. actually placed vs. failed.
+  // Previously `counts.images` reported `sources_that_existed`, which hid
+  // per-file symlink/copy failures and made partial exports look complete.
+  let imagesExpected = 0;
+  let imagesActual = 0;
+  const imagesFailed = []; // [{record_id, reason}]
   if (profile.include_images && imagePaths.length > 0) {
+    // D-008: Windows symlink semantics differ (require admin or dev mode);
+    // refuse symlink mode on Windows and require --copy for portability.
+    if (!options.copy && platform() === 'win32') {
+      throw inputError(
+        'SYMLINK_UNSUPPORTED_WINDOWS',
+        'Symlink mode is not supported on Windows export (target semantics differ and break on archive).',
+        'Re-run with --copy to produce a portable, self-contained export.',
+      );
+    }
+    if (!options.copy) {
+      warnings.push(
+        'Export uses relative symlinks — package is NOT portable across machines. ' +
+        'Use --copy for cross-machine transfer or archival.',
+      );
+    }
+
     const imagesDir = join(exportDir, 'images');
     await mkdir(imagesDir, { recursive: true });
 
-    let linked = 0;
+    imagesExpected = imagePaths.length;
     for (const img of imagePaths) {
       const dest = join(imagesDir, img.filename);
-      if (existsSync(img.source)) {
-        try {
-          if (options.copy) {
-            await copyFile(img.source, dest);
-          } else {
-            const relPath = relative(imagesDir, img.source);
-            await symlink(relPath, dest);
-          }
-          linked++;
-        } catch {
-          // Skip individual failures (e.g. duplicate filenames)
+      if (!existsSync(img.source)) {
+        // DB-002: source-missing is a distinct failure mode from link/copy error.
+        imagesFailed.push({ record_id: img.record_id, reason: 'source_missing' });
+        continue;
+      }
+      try {
+        if (options.copy) {
+          await copyFile(img.source, dest);
+        } else {
+          const relPath = relative(imagesDir, img.source);
+          await symlink(relPath, dest);
         }
+        imagesActual++;
+      } catch (err) {
+        // DB-002: capture the specific placement failure for operator triage.
+        imagesFailed.push({
+          record_id: img.record_id,
+          reason: options.copy ? 'copy_failed' : 'link_failed',
+          detail: err.message,
+        });
       }
     }
+
+    // DB-002: surface partial placement failures loudly — silent `catch {}`
+    // previously hid this and made exports appear complete when 20% of
+    // images had actually been dropped.
+    if (imagesFailed.length > 0) {
+      const sample = imagesFailed.slice(0, 10).map(f => `${f.record_id} (${f.reason})`);
+      const msg =
+        `export: ${imagesFailed.length} of ${imagesExpected} images failed to place` +
+        (imagesFailed.length > 10 ? ` — first 10: ${sample.join(', ')}, ...` : ` — ${sample.join(', ')}`);
+      warn(msg);
+      warnings.push(msg);
+    }
   }
 
   // Splits
@@ -144,34 +238,35 @@ export async function buildExport(projectRoot, snapshotId, splitId, options = {}
     await writeFile(join(exportDir, 'dataset-card.json'), JSON.stringify(json, null, 2) + '\n');
   }
 
-  // Checksums
-  if (profile.include_checksums) {
-    // Checksum all files in the export dir (except checksums.txt itself)
-    const allFiles = await collectFiles(exportDir);
-    for (const filePath of allFiles.sort()) {
-      const relPath = relative(exportDir, filePath);
-      if (relPath === 'checksums.txt') continue;
-      const hash = await sha256File(filePath);
-      checksumEntries.push(`SHA256 (${relPath}) = ${hash}`);
-    }
-    await writeFile(join(exportDir, 'checksums.txt'), checksumEntries.join('\n') + '\n');
-  }
-
-  // Manifest (written last — references everything)
+  // D-015: Write manifest + summary FIRST so they are covered by checksums.
+  // D-001: Inherit snapshot's config_fingerprint (we verified above it matches
+  // current state) — never recompute independently at export time.
   const manifest = {
+    // DB-001 / DB-006: stamp manifest schema version
+    schema_version: SCHEMA_VERSION,
     export_id: exportId,
     created_at: new Date().toISOString(),
     created_by: 'sdlab-export-v1',
     project: config.meta.name,
     snapshot_id: snapshotId,
     split_id: splitId,
-    config_fingerprint: computeConfigFingerprint(projectRoot),
+    config_fingerprint: snapshot.config_fingerprint,
     profile,
+    warnings,
     counts: {
       records: metadata.length,
-      images: imagePaths.filter(i => existsSync(i.source)).length,
-      checksums: checksumEntries.length,
+      // DB-002: images count is the actual placed count (not source-exists).
+      // Keep top-level `images` for backward compat with older manifest readers
+      // that indexed it as the summary number, but add structured detail.
+      images: imagesActual,
+      images_expected: imagesExpected,
+      images_actual: imagesActual,
+      images_failed: imagesFailed.length,
+      checksums: 0, // updated after checksum pass below
     },
+    // DB-002: record-level failure detail so operators can investigate
+    // without re-opening the directory to discover what's missing.
+    images_failed: imagesFailed,
   };
   await writeFile(join(exportDir, 'manifest.json'), JSON.stringify(manifest, null, 2) + '\n');
 
@@ -188,9 +283,22 @@ export async function buildExport(projectRoot, snapshotId, splitId, options = {}
       test: split.counts.test,
     },
     config_fingerprint: manifest.config_fingerprint,
+    warnings,
   };
   await writeFile(join(exportDir, 'summary.json'), JSON.stringify(summary, null, 2) + '\n');
 
+  // Checksums (computed AFTER manifest+summary so they are included)
+  if (profile.include_checksums) {
+    const allFiles = await collectFiles(exportDir);
+    for (const filePath of allFiles.sort()) {
+      const relPath = relative(exportDir, filePath);
+      if (relPath === 'checksums.txt') continue;
+      const hash = await sha256File(filePath);
+      checksumEntries.push(`SHA256 (${relPath}) = ${hash}`);
+    }
+    await writeFile(join(exportDir, 'checksums.txt'), checksumEntries.join('\n') + '\n');
+  }
+
   return {
     exportId,
     recordCount: metadata.length,
@@ -255,5 +363,7 @@ export async function loadExport(projectRoot, exportId) {
   if (!existsSync(path)) {
     throw new Error(`Export "${exportId}" not found at ${path}`);
   }
-  return JSON.parse(await readFile(path, 'utf-8'));
+  const manifest = JSON.parse(await readFile(path, 'utf-8'));
+  checkManifestVersion(manifest, 'export');
+  return manifest;
 }

package/lib/generated-provenance.js

@@ -0,0 +1,87 @@
+/**
+ * Generated provenance builder — constructs the provenance block
+ * attached to records created from selected run/batch outputs.
+ *
+ * Normalizes source context (run vs batch) into a single shape
+ * that traces back through brief → workflow → seed → config.
+ */
+
+import { readFileSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { createHash } from 'node:crypto';
+
+/**
+ * Build a generation provenance payload for a selected output.
+ *
+ * @param {Object} opts
+ * @param {'run'|'batch'} opts.sourceType
+ * @param {string} opts.sourceId — run_id or batch_id
+ * @param {Object} opts.runManifest — the run manifest containing this output
+ * @param {Object} [opts.batchManifest] — batch manifest if source is batch
+ * @param {Object} opts.item — the selection item (slot_or_output, filename, seed)
+ * @param {string} opts.projectRoot
+ * @returns {Object} generation_provenance block
+ */
+export function buildGeneratedProvenance({
+  sourceType,
+  sourceId,
+  runManifest,
+  batchManifest,
+  item,
+  projectRoot,
+}) {
+  const prov = {
+    source_type: sourceType,
+    source_id: sourceId,
+    run_id: runManifest.run_id,
+    brief_id: runManifest.brief_id,
+    workflow_id: runManifest.workflow_template_id,
+    selected_filename: item.filename,
+    generated_at: runManifest.created_at,
+  };
+
+  if (sourceType === 'batch' && batchManifest) {
+    prov.batch_id = batchManifest.batch_id;
+  }
+
+  // Seed from the item or from the run manifest outputs
+  if (item.seed !== undefined) {
+    prov.seed = item.seed;
+  } else if (runManifest.outputs) {
+    const match = runManifest.outputs.find(o => o.filename === item.filename);
+    if (match?.seed !== undefined) prov.seed = match.seed;
+  }
+
+  // Adapter target from run manifest
+  if (runManifest.adapter_target) {
+    prov.adapter_target = runManifest.adapter_target;
+  }
+
+  // Subject from run brief or batch manifest
+  if (batchManifest?.subject_id) {
+    prov.subject_id = batchManifest.subject_id;
+  } else {
+    // Try to read subject from brief
+    const briefPath = join(projectRoot, 'briefs', `${runManifest.brief_id}.json`);
+    if (existsSync(briefPath)) {
+      try {
+        const brief = JSON.parse(readFileSync(briefPath, 'utf-8'));
+        if (brief.subject_id) prov.subject_id = brief.subject_id;
+        if (brief.parent_brief_id) prov.parent_brief_id = brief.parent_brief_id;
+      } catch { /* skip */ }
+    }
+  }
+
+  // Config fingerprint — hash the run manifest for reproducibility tracing
+  prov.config_fingerprint = createHash('sha256')
+    .update(JSON.stringify({
+      brief_id: runManifest.brief_id,
+      workflow_template_id: runManifest.workflow_template_id,
+      adapter_target: runManifest.adapter_target,
+      seed_plan: runManifest.seed_plan,
+    }))
+    .digest('hex')
+    .slice(0, 16);
+
+  return prov;
+}

package/lib/implementation-packs.js

@@ -17,6 +17,8 @@ import { loadTrainingProfile } from './training-profiles.js';
 import { loadProjectConfig, detectLane, detectGroup } from './config.js';
 import { loadSplitPartition } from './split.js';
 import { loadRecord } from './records.js';
+import { inputError } from './errors.js';
+import { SCHEMA_VERSION, checkManifestVersion } from './snapshot.js';
 
 function generateImplId() {
   const now = new Date();
@@ -138,9 +140,19 @@ export async function buildImplementationPack(projectRoot, manifestId) {
   // Write implementation pack
   const implId = generateImplId();
   const implDir = join(projectRoot, 'training', 'implementations', implId);
+  // D-005: refuse to silently overwrite on ID collision.
+  if (existsSync(implDir)) {
+    throw inputError(
+      'IMPL_PACK_ID_COLLISION',
+      `Implementation pack directory already exists: ${implDir}`,
+      'Retry to generate a fresh implementation pack ID.',
+    );
+  }
   await mkdir(implDir, { recursive: true });
 
   const implManifest = {
+    // DB-001 / DB-006: stamp manifest schema version
+    schema_version: SCHEMA_VERSION,
     implementation_pack_id: implId,
     created_at: new Date().toISOString(),
     created_by: 'sdlab-implementation-v1',
@@ -312,5 +324,7 @@ export async function loadImplementationPack(projectRoot, implId) {
   if (!existsSync(path)) {
     throw new Error(`Implementation pack "${implId}" not found at ${path}`);
   }
-  return JSON.parse(await readFile(path, 'utf-8'));
+  const manifest = JSON.parse(await readFile(path, 'utf-8'));
+  checkManifestVersion(manifest, 'implementation-pack');
+  return manifest;
 }