@mcptoolshop/style-dataset-lab 2.1.0 → 2.2.0

package/scripts/eval-run.js

@@ -0,0 +1,121 @@
+#!/usr/bin/env node
+
+/**
+ * eval-run.js — Create, score, and inspect eval runs.
+ *
+ * Usage:
+ *   sdlab eval-run create --manifest <id> --eval-pack <id> [--project <name>]
+ *   sdlab eval-run score <eval-run-id> --outputs <path> [--project <name>]
+ *   sdlab eval-run show <eval-run-id> [--project <name>]
+ *   sdlab eval-run list [--project <name>]
+ */
+
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { getProjectName } from '../lib/args.js';
+import { REPO_ROOT } from '../lib/paths.js';
+import { listTrainingManifests } from '../lib/training-manifests.js';
+import { listEvalPacks } from '../lib/eval-pack.js';
+import { createEvalRun, scoreEvalRun, loadEvalRun, listEvalRuns } from '../lib/eval-runs.js';
+
+export async function run(argv = process.argv.slice(2)) {
+  const projectName = getProjectName(argv);
+  const projectRoot = join(REPO_ROOT, 'projects', projectName);
+  const subcommand = argv.find(a => !a.startsWith('--') && !a.startsWith('er-')) || 'list';
+  const args = argv.filter(a => a !== subcommand);
+
+  if (subcommand === 'create') {
+    // Find manifest
+    let manifestId;
+    const manifestIdx = args.indexOf('--manifest');
+    if (manifestIdx >= 0) {
+      manifestId = args[manifestIdx + 1];
+    } else {
+      const manifests = await listTrainingManifests(projectRoot);
+      if (manifests.length === 0) throw new Error('No training manifests. Run: sdlab training-manifest create');
+      manifestId = manifests[manifests.length - 1].id;
+    }
+
+    // Find eval pack
+    let evalPackId;
+    const evalIdx = args.indexOf('--eval-pack');
+    if (evalIdx >= 0) {
+      evalPackId = args[evalIdx + 1];
+    } else {
+      const packs = await listEvalPacks(projectRoot);
+      if (packs.length === 0) throw new Error('No eval packs. Run: sdlab eval-pack build');
+      evalPackId = packs[packs.length - 1].id;
+    }
+
+    console.log(`\x1b[1msdlab eval-run create\x1b[0m — ${projectName}`);
+    console.log(`  Manifest:  ${manifestId}`);
+    console.log(`  Eval pack: ${evalPackId}`);
+    console.log('');
+
+    const result = await createEvalRun(projectRoot, manifestId, evalPackId);
+    console.log(`  \x1b[32m✓\x1b[0m Eval run: ${result.evalRunId}`);
+    console.log(`  Status: created (use "sdlab eval-run score" to score outputs)`);
+
+  } else if (subcommand === 'score') {
+    const evalRunId = args.find(a => a.startsWith('er-'));
+    if (!evalRunId) throw new Error('Usage: sdlab eval-run score <eval-run-id> --outputs <path>');
+
+    const outputsIdx = args.indexOf('--outputs');
+    if (outputsIdx < 0) throw new Error('--outputs <path> is required (JSONL with record_id, accept, notes)');
+    const outputsPath = args[outputsIdx + 1];
+
+    console.log(`\x1b[1msdlab eval-run score\x1b[0m — ${evalRunId}\n`);
+
+    const { scorecard } = await scoreEvalRun(projectRoot, evalRunId, outputsPath);
+
+    const verdict = scorecard.overall_verdict === 'pass'
+      ? `\x1b[32mPASS\x1b[0m` : `\x1b[31mFAIL\x1b[0m`;
+    console.log(`  Verdict: ${verdict} (${(scorecard.overall_score * 100).toFixed(1)}%)`);
+    console.log(`  Outputs: ${scorecard.output_count} (${scorecard.accepted_count} accepted, ${scorecard.rejected_count} rejected)`);
+    console.log('');
+    console.log('  Tasks:');
+    for (const [name, task] of Object.entries(scorecard.tasks)) {
+      const status = task.passed ? '\x1b[32m✓\x1b[0m' : '\x1b[31m✗\x1b[0m';
+      console.log(`    ${status} ${name.padEnd(24)} ${(task.score * 100).toFixed(1)}%`);
+    }
+
+  } else if (subcommand === 'show') {
+    const evalRunId = args.find(a => a.startsWith('er-'));
+    if (!evalRunId) throw new Error('Usage: sdlab eval-run show <eval-run-id>');
+
+    const run = await loadEvalRun(projectRoot, evalRunId);
+    console.log(`\x1b[1mEval run\x1b[0m — ${evalRunId}\n`);
+    console.log(`  Created:   ${run.created_at}`);
+    console.log(`  Status:    ${run.status}`);
+    console.log(`  Manifest:  ${run.training_manifest_id}`);
+    console.log(`  Eval pack: ${run.eval_pack_id}`);
+    console.log(`  Profile:   ${run.training_profile_id}`);
+    console.log(`  Adapter:   ${run.adapter_target}`);
+
+    if (run.scorecard) {
+      console.log('');
+      console.log(`  Verdict:   ${run.scorecard.overall_verdict.toUpperCase()}`);
+      console.log(`  Score:     ${(run.scorecard.overall_score * 100).toFixed(1)}%`);
+      console.log(`  Outputs:   ${run.scorecard.output_count} (${run.scorecard.accepted_count} accepted)`);
+    }
+
+  } else if (subcommand === 'list') {
+    const runs = await listEvalRuns(projectRoot);
+    if (runs.length === 0) {
+      console.log('No eval runs found. Run: sdlab eval-run create');
+      return;
+    }
+    console.log(`\x1b[1mEval runs\x1b[0m — ${projectName}\n`);
+    for (const r of runs) {
+      const verdict = r.verdict ? ` verdict=${r.verdict}` : '';
+      console.log(`  ${r.id}  manifest=${r.manifest}  status=${r.status}${verdict}  ${r.created_at}`);
+    }
+
+  } else {
+    throw new Error(`Unknown subcommand: ${subcommand}. Use: create, score, show, list`);
+  }
+}
+
+if (process.argv[1] && (process.argv[1].endsWith('eval-run.js') || process.argv[1].endsWith('eval-run'))) {
+  run().catch((err) => { console.error(err.message || err); process.exit(1); });
+}

package/scripts/implementation-pack.js

@@ -0,0 +1,78 @@
+#!/usr/bin/env node
+
+/**
+ * implementation-pack.js — Build and inspect implementation example packs.
+ *
+ * Usage:
+ *   sdlab implementation-pack build --manifest <id> [--project <name>]
+ *   sdlab implementation-pack show <impl-id> [--project <name>]
+ *   sdlab implementation-pack list [--project <name>]
+ */
+
+import { join } from 'node:path';
+import { getProjectName } from '../lib/args.js';
+import { REPO_ROOT } from '../lib/paths.js';
+import { listTrainingManifests } from '../lib/training-manifests.js';
+import { buildImplementationPack, listImplementationPacks, loadImplementationPack } from '../lib/implementation-packs.js';
+
+export async function run(argv = process.argv.slice(2)) {
+  const projectName = getProjectName(argv);
+  const projectRoot = join(REPO_ROOT, 'projects', projectName);
+  const subcommand = argv.find(a => !a.startsWith('--') && !a.startsWith('impl-') && !a.startsWith('tm-')) || 'list';
+  const args = argv.filter(a => a !== subcommand);
+
+  if (subcommand === 'build') {
+    let manifestId;
+    const manifestIdx = args.indexOf('--manifest');
+    if (manifestIdx >= 0) {
+      manifestId = args[manifestIdx + 1];
+    } else {
+      const manifests = await listTrainingManifests(projectRoot);
+      if (manifests.length === 0) throw new Error('No training manifests. Run: sdlab training-manifest create');
+      manifestId = manifests[manifests.length - 1].id;
+    }
+
+    console.log(`\x1b[1msdlab implementation-pack build\x1b[0m — ${projectName}`);
+    console.log(`  Manifest: ${manifestId}`);
+    console.log('');
+
+    const result = await buildImplementationPack(projectRoot, manifestId);
+
+    console.log(`  \x1b[32m✓\x1b[0m Implementation pack: ${result.implId}`);
+    console.log(`  Prompt examples:      ${result.prompts}`);
+    console.log(`  Known failures:       ${result.failures}`);
+    console.log(`  Subject continuity:   ${result.subjects}`);
+
+  } else if (subcommand === 'show') {
+    const implId = args.find(a => a.startsWith('impl-'));
+    if (!implId) throw new Error('Usage: sdlab implementation-pack show <impl-id>');
+
+    const pack = await loadImplementationPack(projectRoot, implId);
+    console.log(`\x1b[1mImplementation pack\x1b[0m — ${implId}\n`);
+    console.log(`  Created:    ${pack.created_at}`);
+    console.log(`  Manifest:   ${pack.training_manifest_id}`);
+    console.log(`  Profile:    ${pack.training_profile_id}`);
+    console.log(`  Prompts:    ${pack.counts.prompt_examples}`);
+    console.log(`  Failures:   ${pack.counts.known_failures}`);
+    console.log(`  Subjects:   ${pack.counts.subject_examples}`);
+    console.log(`  Lanes:      ${pack.counts.lanes_covered}`);
+
+  } else if (subcommand === 'list') {
+    const packs = await listImplementationPacks(projectRoot);
+    if (packs.length === 0) {
+      console.log('No implementation packs. Run: sdlab implementation-pack build');
+      return;
+    }
+    console.log(`\x1b[1mImplementation packs\x1b[0m — ${projectName}\n`);
+    for (const p of packs) {
+      console.log(`  ${p.id}  manifest=${p.manifest}  prompts=${p.prompts}  failures=${p.failures}  ${p.created_at}`);
+    }
+
+  } else {
+    throw new Error(`Unknown subcommand: ${subcommand}. Use: build, show, list`);
+  }
+}
+
+if (process.argv[1] && (process.argv[1].endsWith('implementation-pack.js') || process.argv[1].endsWith('implementation-pack'))) {
+  run().catch((err) => { console.error(err.message || err); process.exit(1); });
+}

package/scripts/init.js

@@ -35,6 +35,11 @@ const PROJECT_DIRS = [
   'snapshots',
   'splits',
   'eval-packs',
+  'training/profiles',
+  'training/manifests',
+  'training/packages',
+  'training/eval-runs',
+  'training/implementations',
 ];
 
 function isValidName(name) {

package/scripts/reingest.js

@@ -0,0 +1,86 @@
+#!/usr/bin/env node
+
+/**
+ * reingest.js — Re-ingest generated outputs as new project records.
+ *
+ * Usage:
+ *   sdlab reingest generated --source <dir> --manifest <id> [--dry-run] [--project <name>]
+ *   sdlab reingest audit [--project <name>]
+ */
+
+import { join } from 'node:path';
+import { getProjectName } from '../lib/args.js';
+import { REPO_ROOT } from '../lib/paths.js';
+import { reingestGenerated, auditReingest } from '../lib/reingest.js';
+
+export async function run(argv = process.argv.slice(2)) {
+  const projectName = getProjectName(argv);
+  const projectRoot = join(REPO_ROOT, 'projects', projectName);
+  const subcommand = argv.find(a => !a.startsWith('--')) || 'audit';
+  const args = argv.filter(a => a !== subcommand);
+
+  if (subcommand === 'generated') {
+    const sourceIdx = args.indexOf('--source');
+    if (sourceIdx < 0) throw new Error('--source <dir> is required (directory of generated images)');
+    const sourcePath = args[sourceIdx + 1];
+
+    const manifestIdx = args.indexOf('--manifest');
+    if (manifestIdx < 0) throw new Error('--manifest <id> is required (training manifest that produced the outputs)');
+    const manifestId = args[manifestIdx + 1];
+
+    const dryRun = args.includes('--dry-run');
+
+    console.log(`\x1b[1msdlab reingest generated\x1b[0m — ${projectName}`);
+    console.log(`  Source:   ${sourcePath}`);
+    console.log(`  Manifest: ${manifestId}`);
+    if (dryRun) console.log(`  Mode:     DRY RUN (no records written)`);
+    console.log('');
+
+    const result = await reingestGenerated(projectRoot, sourcePath, manifestId, { dryRun });
+
+    console.log(`  \x1b[32m✓\x1b[0m Created: ${result.created} records`);
+    if (result.skipped > 0) {
+      console.log(`  Skipped: ${result.skipped} (already exist)`);
+    }
+    if (result.created > 0) {
+      console.log('');
+      console.log('  Next steps:');
+      console.log('    1. Review: sdlab curate <id> approved/rejected "explanation"');
+      console.log('    2. Bind:   sdlab bind --project ' + projectName);
+      console.log('    3. Then eligible for future snapshots');
+    }
+
+  } else if (subcommand === 'audit') {
+    console.log(`\x1b[1msdlab reingest audit\x1b[0m — ${projectName}\n`);
+
+    const result = await auditReingest(projectRoot);
+
+    if (result.total === 0) {
+      console.log('  No re-ingested records found (gen_* prefix).');
+      return;
+    }
+
+    console.log(`  Re-ingested records: ${result.total}`);
+    console.log(`  Reviewed:            ${result.reviewed}`);
+    console.log(`  Unreviewed:          ${result.unreviewed}`);
+    console.log(`  Canon-bound:         ${result.bound}`);
+    console.log(`  Unbound:             ${result.unbound}`);
+
+    if (result.unreviewed > 0) {
+      console.log(`\n  \x1b[33m⚠\x1b[0m ${result.unreviewed} records awaiting review`);
+    }
+    if (result.unbound > 0) {
+      console.log(`  \x1b[33m⚠\x1b[0m ${result.unbound} reviewed records not yet canon-bound`);
+    }
+    if (result.unreviewed === 0 && result.unbound === 0) {
+      console.log(`\n  \x1b[32m✓\x1b[0m All re-ingested records are reviewed and canon-bound`);
+    }
+
+  } else {
+    throw new Error(`Unknown subcommand: ${subcommand}. Use: generated, audit`);
+  }
+}
+
+if (process.argv[1] && (process.argv[1].endsWith('reingest.js') || process.argv[1].endsWith('reingest'))) {
+  run().catch((err) => { console.error(err.message || err); process.exit(1); });
+}

package/scripts/training-manifest.js

@@ -0,0 +1,119 @@
+#!/usr/bin/env node
+
+/**
+ * training-manifest.js — Create, validate, list, and show training manifests.
+ *
+ * Usage:
+ *   sdlab training-manifest create --export <id> --profile <id> [--adapter <target>] [--base-model <name>] [--project <name>]
+ *   sdlab training-manifest validate <manifest-id> [--project <name>]
+ *   sdlab training-manifest show <manifest-id> [--project <name>]
+ *   sdlab training-manifest list [--project <name>]
+ */
+
+import { join } from 'node:path';
+import { getProjectName } from '../lib/args.js';
+import { REPO_ROOT } from '../lib/paths.js';
+import { listExports } from '../lib/export.js';
+import {
+  createTrainingManifest,
+  validateTrainingManifest,
+  loadTrainingManifest,
+  listTrainingManifests,
+} from '../lib/training-manifests.js';
+
+export async function run(argv = process.argv.slice(2)) {
+  const projectName = getProjectName(argv);
+  const projectRoot = join(REPO_ROOT, 'projects', projectName);
+  const subcommand = argv.find(a => !a.startsWith('--') && !a.startsWith('tm-')) || 'list';
+  const args = argv.filter(a => a !== subcommand);
+
+  if (subcommand === 'create') {
+    // Required: --export and --profile
+    const exportIdx = args.indexOf('--export');
+    if (exportIdx < 0) {
+      // Try latest export
+      const exports = await listExports(projectRoot);
+      if (exports.length === 0) throw new Error('No exports found. Run: sdlab export build');
+    }
+    const exportId = exportIdx >= 0 ? args[exportIdx + 1] : (await listExports(projectRoot)).pop().id;
+
+    const profileIdx = args.indexOf('--profile');
+    if (profileIdx < 0) throw new Error('--profile is required. Use: sdlab training-profile list');
+    const profileId = args[profileIdx + 1];
+
+    const adapterIdx = args.indexOf('--adapter');
+    const adapterTarget = adapterIdx >= 0 ? args[adapterIdx + 1] : undefined;
+
+    const baseModelIdx = args.indexOf('--base-model');
+    const baseModel = baseModelIdx >= 0 ? args[baseModelIdx + 1] : undefined;
+
+    console.log(`\x1b[1msdlab training-manifest create\x1b[0m — ${projectName}`);
+    console.log(`  Export:  ${exportId}`);
+    console.log(`  Profile: ${profileId}`);
+    if (adapterTarget) console.log(`  Adapter: ${adapterTarget}`);
+    if (baseModel) console.log(`  Base:    ${baseModel}`);
+    console.log('');
+
+    const result = await createTrainingManifest(projectRoot, exportId, profileId, {
+      adapterTarget,
+      baseModel,
+    });
+
+    console.log(`  \x1b[32m✓\x1b[0m Manifest: ${result.manifestId}`);
+
+  } else if (subcommand === 'validate') {
+    const manifestId = args.find(a => a.startsWith('tm-'));
+    if (!manifestId) throw new Error('Usage: sdlab training-manifest validate <manifest-id>');
+
+    console.log(`\x1b[1msdlab training-manifest validate\x1b[0m — ${manifestId}\n`);
+    const { valid, issues } = await validateTrainingManifest(projectRoot, manifestId);
+
+    if (valid) {
+      console.log(`  \x1b[32m✓\x1b[0m Manifest is valid — all references intact, fingerprints match`);
+    } else {
+      console.log(`  \x1b[31m✗\x1b[0m Manifest has issues:`);
+      for (const issue of issues) {
+        console.log(`    - ${issue}`);
+      }
+    }
+
+  } else if (subcommand === 'show') {
+    const manifestId = args.find(a => a.startsWith('tm-'));
+    if (!manifestId) throw new Error('Usage: sdlab training-manifest show <manifest-id>');
+
+    const manifest = await loadTrainingManifest(projectRoot, manifestId);
+    console.log(`\x1b[1mTraining manifest\x1b[0m — ${manifestId}\n`);
+    console.log(`  Created:     ${manifest.created_at}`);
+    console.log(`  Profile:     ${manifest.training_profile_id}`);
+    console.log(`  Export:      ${manifest.source_export_id}`);
+    console.log(`  Snapshot:    ${manifest.source_snapshot_id}`);
+    console.log(`  Split:       ${manifest.source_split_id}`);
+    console.log(`  Adapter:     ${manifest.adapter_target}`);
+    console.log(`  Base model:  ${manifest.base_model || '(not specified)'}`);
+    console.log(`  Caption:     ${manifest.caption_mode}`);
+    console.log(`  Records:     ${manifest.dataset_counts?.records || 0}`);
+    console.log(`  Fingerprint: ${manifest.config_fingerprint.slice(0, 16)}...`);
+    console.log(`  Export hash: ${manifest.export_manifest_hash.slice(0, 16)}...`);
+    if (manifest.linked_eval_pack_ids?.length) {
+      console.log(`  Eval packs:  ${manifest.linked_eval_pack_ids.length}`);
+    }
+
+  } else if (subcommand === 'list') {
+    const manifests = await listTrainingManifests(projectRoot);
+    if (manifests.length === 0) {
+      console.log('No training manifests found. Run: sdlab training-manifest create');
+      return;
+    }
+    console.log(`\x1b[1mTraining manifests\x1b[0m — ${projectName}\n`);
+    for (const m of manifests) {
+      console.log(`  ${m.id}  profile=${m.profile}  export=${m.export_id}  adapter=${m.adapter}  records=${m.records}  ${m.created_at}`);
+    }
+
+  } else {
+    throw new Error(`Unknown subcommand: ${subcommand}. Use: create, validate, show, list`);
+  }
+}
+
+if (process.argv[1] && (process.argv[1].endsWith('training-manifest.js') || process.argv[1].endsWith('training-manifest'))) {
+  run().catch((err) => { console.error(err.message || err); process.exit(1); });
+}

package/scripts/training-package.js

@@ -0,0 +1,84 @@
+#!/usr/bin/env node
+
+/**
+ * training-package.js — Build and inspect training packages.
+ *
+ * Usage:
+ *   sdlab training-package build --manifest <id> [--adapter <target>] [--copy] [--project <name>]
+ *   sdlab training-package show <package-id> [--project <name>]
+ *   sdlab training-package list [--project <name>]
+ */
+
+import { join } from 'node:path';
+import { getProjectName } from '../lib/args.js';
+import { REPO_ROOT } from '../lib/paths.js';
+import { listTrainingManifests } from '../lib/training-manifests.js';
+import { buildTrainingPackage, listTrainingPackages, loadTrainingPackage } from '../lib/training-packages.js';
+
+export async function run(argv = process.argv.slice(2)) {
+  const projectName = getProjectName(argv);
+  const projectRoot = join(REPO_ROOT, 'projects', projectName);
+  const subcommand = argv.find(a => !a.startsWith('--') && !a.startsWith('tp-') && !a.startsWith('tm-')) || 'list';
+  const args = argv.filter(a => a !== subcommand);
+
+  if (subcommand === 'build') {
+    // Find manifest
+    let manifestId;
+    const manifestIdx = args.indexOf('--manifest');
+    if (manifestIdx >= 0) {
+      manifestId = args[manifestIdx + 1];
+    } else {
+      const manifests = await listTrainingManifests(projectRoot);
+      if (manifests.length === 0) throw new Error('No training manifests found. Run: sdlab training-manifest create');
+      manifestId = manifests[manifests.length - 1].id;
+    }
+
+    const adapterIdx = args.indexOf('--adapter');
+    const adapterOverride = adapterIdx >= 0 ? args[adapterIdx + 1] : undefined;
+    const copy = args.includes('--copy');
+
+    console.log(`\x1b[1msdlab training-package build\x1b[0m — ${projectName}`);
+    console.log(`  Manifest: ${manifestId}`);
+    if (adapterOverride) console.log(`  Adapter:  ${adapterOverride}`);
+    console.log(`  Images:   ${copy ? 'copy' : 'symlink'}`);
+    console.log('');
+
+    const result = await buildTrainingPackage(projectRoot, manifestId, { copy, adapterOverride });
+
+    console.log(`  \x1b[32m✓\x1b[0m Package: ${result.packageId}`);
+    console.log(`  Records: ${result.records}`);
+    console.log(`  Images:  ${result.images}`);
+
+  } else if (subcommand === 'show') {
+    const packageId = args.find(a => a.startsWith('tp-'));
+    if (!packageId) throw new Error('Usage: sdlab training-package show <package-id>');
+
+    const pkg = await loadTrainingPackage(projectRoot, packageId);
+    console.log(`\x1b[1mTraining package\x1b[0m — ${packageId}\n`);
+    console.log(`  Created:  ${pkg.created_at}`);
+    console.log(`  Profile:  ${pkg.training_profile_id}`);
+    console.log(`  Adapter:  ${pkg.adapter_target}`);
+    console.log(`  Manifest: ${pkg.training_manifest_id}`);
+    console.log(`  Export:   ${pkg.source_export_id}`);
+    console.log(`  Records:  ${pkg.counts.total_records} (train=${pkg.counts.train} val=${pkg.counts.val} test=${pkg.counts.test})`);
+    console.log(`  Images:   ${pkg.counts.images}`);
+
+  } else if (subcommand === 'list') {
+    const packages = await listTrainingPackages(projectRoot);
+    if (packages.length === 0) {
+      console.log('No training packages found. Run: sdlab training-package build');
+      return;
+    }
+    console.log(`\x1b[1mTraining packages\x1b[0m — ${projectName}\n`);
+    for (const p of packages) {
+      console.log(`  ${p.id}  profile=${p.profile}  adapter=${p.adapter}  records=${p.records}  images=${p.images}  ${p.created_at}`);
+    }
+
+  } else {
+    throw new Error(`Unknown subcommand: ${subcommand}. Use: build, show, list`);
+  }
+}
+
+if (process.argv[1] && (process.argv[1].endsWith('training-package.js') || process.argv[1].endsWith('training-package'))) {
+  run().catch((err) => { console.error(err.message || err); process.exit(1); });
+}

package/scripts/training-profile.js

@@ -0,0 +1,63 @@
+#!/usr/bin/env node
+
+/**
+ * training-profile.js — List and show training profiles.
+ *
+ * Usage:
+ *   sdlab training-profile list [--project <name>]
+ *   sdlab training-profile show <profile-id> [--project <name>]
+ */
+
+import { join } from 'node:path';
+import { getProjectName } from '../lib/args.js';
+import { REPO_ROOT } from '../lib/paths.js';
+import { listTrainingProfiles, loadTrainingProfile } from '../lib/training-profiles.js';
+
+export async function run(argv = process.argv.slice(2)) {
+  const projectName = getProjectName(argv);
+  const projectRoot = join(REPO_ROOT, 'projects', projectName);
+  const subcommand = argv.find(a => !a.startsWith('--')) || 'list';
+  const args = argv.filter(a => a !== subcommand);
+
+  if (subcommand === 'list') {
+    const profiles = await listTrainingProfiles(projectRoot);
+    if (profiles.length === 0) {
+      console.log('No training profiles found. Add JSON files to training/profiles/');
+      return;
+    }
+    console.log(`\x1b[1mTraining profiles\x1b[0m — ${projectName}\n`);
+    for (const p of profiles) {
+      console.log(`  ${p.profile_id.padEnd(30)} ${p.target_family.padEnd(15)} ${p.asset_type.padEnd(10)} lanes=${p.lanes}  adapters=${p.adapters.join(',')}`);
+    }
+
+  } else if (subcommand === 'show') {
+    const profileId = args.find(a => !a.startsWith('--'));
+    if (!profileId) throw new Error('Usage: sdlab training-profile show <profile-id>');
+
+    const profile = await loadTrainingProfile(projectRoot, profileId);
+    console.log(`\x1b[1mTraining profile\x1b[0m — ${profileId}\n`);
+    console.log(`  Label:           ${profile.label}`);
+    console.log(`  Target family:   ${profile.target_family}`);
+    console.log(`  Asset type:      ${profile.asset_type}`);
+    console.log(`  Intended use:    ${profile.intended_use || '(not specified)'}`);
+    console.log(`  Eligible lanes:  ${profile.eligible_lanes.join(', ')}`);
+    console.log(`  Adapter targets: ${profile.adapter_targets.join(', ')}`);
+    if (profile.caption_strategy) console.log(`  Caption:         ${profile.caption_strategy}`);
+    if (profile.base_model_recommendations?.length) {
+      console.log(`  Base models:     ${profile.base_model_recommendations.join(', ')}`);
+    }
+    if (profile.excluded_tags?.length) {
+      console.log(`  Excluded tags:   ${profile.excluded_tags.join(', ')}`);
+    }
+    if (profile.required_eval_pack_profiles?.length) {
+      console.log(`  Required evals:  ${profile.required_eval_pack_profiles.join(', ')}`);
+    }
+
+  } else {
+    throw new Error(`Unknown subcommand: ${subcommand}. Use: list, show`);
+  }
+}
+
+if (process.argv[1] && (process.argv[1].endsWith('training-profile.js') || process.argv[1].endsWith('training-profile'))) {
+  run().catch((err) => { console.error(err.message || err); process.exit(1); });
+}