@mcptoolshop/style-dataset-lab 3.0.0 → 3.1.0

package/lib/training-adapters.js

@@ -0,0 +1,79 @@
+/**
+ * Training adapter registry.
+ *
+ * Single source of truth for training-package adapters. Each adapter
+ * lives in `lib/adapters/<id>.js` and exports `buildPackage(opts)`.
+ *
+ * To add a new adapter (e.g. `kohya-lora`, `onedtrainer`):
+ *   1. Add `lib/adapters/<id>.js` exporting `buildPackage`.
+ *   2. Add an entry to ADAPTER_REGISTRY below with a one-line description.
+ *
+ * Why explicit registration: the available adapter list shows up in error
+ * messages, training-profile validation, and (eventually) CLI completion.
+ * A static map keeps those views consistent and makes new adapters a
+ * one-line surface change rather than a directory-listing side effect.
+ */
+
+import { inputError } from './errors.js';
+
+export const ADAPTER_REGISTRY = Object.freeze({
+  'generic-image-caption': {
+    id: 'generic-image-caption',
+    description: 'Image folders + caption JSONL — broadest trainer compatibility',
+    module: './adapters/generic-image-caption.js',
+  },
+  'diffusers-lora': {
+    id: 'diffusers-lora',
+    description: 'Diffusers fine-tuning layout: image + caption .txt sidecars + per-partition JSONL',
+    module: './adapters/diffusers-lora.js',
+  },
+});
+
+/**
+ * Names of all registered adapters.
+ * @returns {string[]}
+ */
+export function listAdapters() {
+  return Object.keys(ADAPTER_REGISTRY);
+}
+
+/**
+ * Whether `id` names a registered adapter.
+ * @param {string} id
+ * @returns {boolean}
+ */
+export function isRegisteredAdapter(id) {
+  return Object.prototype.hasOwnProperty.call(ADAPTER_REGISTRY, id);
+}
+
+/**
+ * Resolve and dynamically import an adapter module.
+ *
+ * Throws `ADAPTER_NOT_REGISTERED` (input error, exit 1) for unknown ids
+ * — distinct from `MODULE_LOAD_FAILED` (runtime, exit 2) for the rare
+ * case where the file vanished after registration.
+ *
+ * @param {string} id
+ * @returns {Promise<{ buildPackage: Function }>}
+ */
+export async function loadAdapter(id) {
+  if (!isRegisteredAdapter(id)) {
+    throw inputError(
+      'ADAPTER_NOT_REGISTERED',
+      `Adapter "${id}" is not registered. Available: ${listAdapters().join(', ')}`,
+      'Pick one of the registered adapters or add a new one to lib/training-adapters.js.'
+    );
+  }
+  const entry = ADAPTER_REGISTRY[id];
+  try {
+    return await import(entry.module);
+  } catch (err) {
+    // The registry says it should exist but import failed — surface the
+    // underlying error so it doesn't get masked as a typo.
+    throw inputError(
+      'ADAPTER_MODULE_LOAD_FAILED',
+      `Adapter "${id}" is registered but its module failed to load: ${err.message}`,
+      `Check that ${entry.module} exists and exports buildPackage().`
+    );
+  }
+}

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,9 @@ 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';
+import { loadAdapter } from './training-adapters.js';
 
 /**
  * Generate a training package ID: tp-YYYYMMDD-HHMMSS-XXXX
@@ -31,20 +34,6 @@ async function sha256File(filePath) {
   return createHash('sha256').update(data).digest('hex');
 }
 
-/**
- * Load an adapter module by name.
- */
-async function loadAdapter(adapterTarget) {
-  const adapterPath = `./adapters/${adapterTarget}.js`;
-  try {
-    return await import(adapterPath);
-  } catch {
-    throw new Error(
-      `Adapter "${adapterTarget}" not found. Available: generic-image-caption, diffusers-lora`
-    );
-  }
-}
-
 /**
  * Build a training package from a manifest.
  *
@@ -63,6 +52,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 +102,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 +122,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 +131,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 +236,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/training-profiles.js

@@ -9,6 +9,7 @@
 import { readFile, readdir, writeFile, mkdir } from 'node:fs/promises';
 import { join } from 'node:path';
 import { existsSync } from 'node:fs';
+import { isRegisteredAdapter, listAdapters } from './training-adapters.js';
 
 const REQUIRED_FIELDS = ['profile_id', 'label', 'target_family', 'asset_type', 'eligible_lanes', 'adapter_targets'];
 
@@ -32,6 +33,15 @@ export function validateProfile(profile) {
   if (profile.adapter_targets?.length === 0) {
     errors.push('adapter_targets must have at least one target');
   }
+  // Reject unregistered adapter targets early — surfaces typos at profile
+  // load time instead of at package-build time.
+  if (Array.isArray(profile.adapter_targets)) {
+    for (const target of profile.adapter_targets) {
+      if (!isRegisteredAdapter(target)) {
+        errors.push(`adapter_targets contains unregistered adapter "${target}". Available: ${listAdapters().join(', ')}`);
+      }
+    }
+  }
   return { valid: errors.length === 0, errors };
 }
 

package/package.json

@@ -1,12 +1,14 @@
 {
   "name": "@mcptoolshop/style-dataset-lab",
-  "version": "3.0.0",
+  "version": "3.1.0",
   "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",
+    "coverage": "c8 npm test",
     "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",
@@ -15,15 +17,34 @@
     "painterly": "node scripts/painterly.js",
     "generate:identity": "node scripts/generate-identity.js"
   },
+  "c8": {
+    "include": ["lib/**/*.js"],
+    "exclude": [
+      "tests/**",
+      "scripts/**",
+      "site/**",
+      "projects/**",
+      "templates/**",
+      "**/*.test.js"
+    ],
+    "reporter": ["text", "lcov", "text-summary"],
+    "report-dir": "coverage",
+    "all": true
+  },
   "files": [
     "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",
@@ -52,5 +73,8 @@
     "node": ">=20"
   },
   "author": "mcp-tool-shop",
-  "license": "MIT"
+  "license": "MIT",
+  "devDependencies": {
+    "c8": "^10.1.3"
+  }
 }

package/scripts/batch-generate.js

@@ -9,61 +9,95 @@
  *   sdlab batch generate --mode silhouette-pack --project star-freight --dry-run
  */
 
-import { parseArgs } from '../lib/args.js';
+import { parseArgs, getProjectName } from '../lib/args.js';
 import { getProjectRoot, getRunsDir } from '../lib/paths.js';
 import { compileBatch } from '../lib/batch-compiler.js';
 import { getBatchMode } from '../lib/batch-modes.js';
 import {
   createBatchDir,
+  openBatchDirForResume,
   executeBatchRuns,
   saveBatchManifest,
 } from '../lib/batch-runs.js';
 import { renderSheetHTML, saveSheet } from '../lib/batch-sheet-render.js';
-import { info } from '../lib/log.js';
+import { info, result } from '../lib/log.js';
 import { join } from 'node:path';
 import { writeFile } from 'node:fs/promises';
 
 export async function run(argv = process.argv.slice(2)) {
   const { flags } = parseArgs(argv, {
     flags: {
-      project: { type: 'string', default: 'star-freight' },
+      project: { type: 'string' },
       mode: { type: 'string' },
       subject: { type: 'string' },
       theme: { type: 'string' },
       asset: { type: 'string' },
+      resume: { type: 'string' },
       'dry-run': { type: 'boolean' },
       json: { type: 'boolean' },
     },
     deprecated: { game: 'project' },
   });
 
-  if (!flags.mode) {
+  if (!flags.mode && !flags.resume) {
     console.log('Usage: sdlab batch generate --mode <id> [--subject <id>] [--theme <label>] [--project <name>]');
+    console.log('       sdlab batch generate --resume <batch_id> [--project <name>]');
     console.log('');
     console.log('Options:');
-    console.log('  --mode <id>        Batch mode (required)');
+    console.log('  --mode <id>        Batch mode (required unless --resume is given)');
     console.log('  --subject <id>     Subject for subject-driven modes');
     console.log('  --theme <label>    Theme label for environment modes');
     console.log('  --asset <id>       Training asset reference');
+    console.log('  --resume <id>      Resume an existing batch — re-runs only failed/missing slots');
     console.log('  --dry-run          Prepare batch without submitting to ComfyUI');
     console.log('  --json             Output manifest as JSON');
     return;
   }
 
-  const projectName = flags.project;
+  const projectName = flags.project || getProjectName(argv);
   const projectRoot = getProjectRoot(projectName);
   const dryRun = flags['dry-run'] || false;
+  const resumeId = flags.resume || null;
+
+  // Resume short-circuit: load prior manifest and reuse its mode_id + subject/theme
+  // so the user only needs to pass --resume <batch_id>.
+  let batchId;
+  let batchDir;
+  let priorResults = [];
+  let resumedMode = null;
+  let resumedSubject = null;
+  let resumedTheme = null;
+  let resumedAsset = null;
+  if (resumeId) {
+    const opened = openBatchDirForResume(projectRoot, resumeId);
+    batchId = opened.batchId;
+    batchDir = opened.batchDir;
+    priorResults = opened.priorResults;
+    resumedMode = opened.priorManifest.mode_id || null;
+    resumedSubject = opened.priorManifest.subject_id || null;
+    resumedTheme = opened.priorManifest.theme || null;
+    resumedAsset = opened.priorManifest.asset_ref || null;
+  }
+
+  const modeId = flags.mode || resumedMode;
+  const subjectId = flags.subject || resumedSubject;
+  const theme = flags.theme || resumedTheme;
+  const assetRef = flags.asset || resumedAsset;
 
   // Load mode for display
-  const mode = getBatchMode(projectRoot, flags.mode);
+  const mode = getBatchMode(projectRoot, modeId);
 
   console.log(`\x1b[1mstyle-dataset-lab\x1b[0m batch generate`);
   console.log(`  Project: ${projectName}`);
   console.log(`  Mode: ${mode.label} (${mode.mode_id})`);
   console.log(`  Type: ${mode.batch_type}`);
   console.log(`  Slots: ${mode.variant_plan.length}`);
-  if (flags.subject) console.log(`  Subject: ${flags.subject}`);
-  if (flags.theme) console.log(`  Theme: ${flags.theme}`);
+  if (subjectId) console.log(`  Subject: ${subjectId}`);
+  if (theme) console.log(`  Theme: ${theme}`);
+  if (resumeId) {
+    const completed = priorResults.filter(r => r && r.status === 'ok').length;
+    console.log(`  Resume: ${resumeId} (${completed}/${priorResults.length} slots already complete)`);
+  }
   if (dryRun) console.log('  ⚠ DRY RUN');
   console.log('');
 
@@ -71,17 +105,22 @@ export async function run(argv = process.argv.slice(2)) {
   const { baseBrief, slotBriefs } = await compileBatch({
     projectRoot,
     projectId: projectName,
-    modeId: flags.mode,
-    subjectId: flags.subject,
-    theme: flags.theme,
-    assetRef: flags.asset,
+    modeId,
+    subjectId,
+    theme,
+    assetRef,
   });
 
-  // 2. Create batch directory
-  const { batchId, batchDir } = await createBatchDir(projectRoot);
-  info(`Batch: ${batchId}`);
+  // 2. Create or reuse batch directory
+  if (!resumeId) {
+    const created = await createBatchDir(projectRoot);
+    batchId = created.batchId;
+    batchDir = created.batchDir;
+  }
+  info('batch-generate', `Batch: ${batchId}`);
 
   // 3. Execute runs
+  const batchStartMs = Date.now();
   const results = await executeBatchRuns({
     projectRoot,
     projectName,
@@ -89,7 +128,14 @@ export async function run(argv = process.argv.slice(2)) {
     mode,
     slotBriefs,
     dryRun,
+    priorResults,
   });
+  const batchElapsedMs = Date.now() - batchStartMs;
+  if (!dryRun && results.length > 0) {
+    const avgSec = Math.round(batchElapsedMs / results.length / 1000);
+    const totalSec = Math.round(batchElapsedMs / 1000);
+    info('batch-generate', `Completed ${results.length} slot(s) in ${totalSec}s (avg ${avgSec}s/slot)`);
+  }
 
   // 4. Build manifest
   const manifest = {
@@ -104,7 +150,9 @@ export async function run(argv = process.argv.slice(2)) {
       label: r.label,
       brief_id: r.brief_id,
       run_id: r.run_id,
+      status: r.status,
       selected_output: r.selected_output,
+      ...(r.error ? { error: r.error } : {}),
     })),
     sheet_paths: [],
     summary: {
@@ -114,8 +162,10 @@ export async function run(argv = process.argv.slice(2)) {
     },
   };
 
-  if (flags.subject) manifest.subject_id = flags.subject;
-  if (flags.theme) manifest.theme = flags.theme;
+  if (subjectId) manifest.subject_id = subjectId;
+  if (theme) manifest.theme = theme;
+  if (assetRef) manifest.asset_ref = assetRef;
+  if (resumeId) manifest.resumed_from = resumeId;
 
   // 5. Render sheet
   const sheetHtml = renderSheetHTML({ manifest, mode, projectRoot, batchDir });
@@ -161,7 +211,9 @@ export async function run(argv = process.argv.slice(2)) {
       console.log(`  ${status} ${r.label.padEnd(24)} → ${r.run_id}  ${r.selected_output || '(dry run)'}`);
     }
     console.log('');
-    info(`Sheet: batches/${batchId}/sheets/primary-sheet.html`);
-    info(`Manifest: batches/${batchId}/manifest.json`);
+    // Primary artifact paths — always print (survives --quiet) so pipelines
+    // can parse the output location.
+    result(`Sheet: batches/${batchId}/sheets/primary-sheet.html`);
+    result(`Manifest: batches/${batchId}/manifest.json`);
   }
 }

package/scripts/batch-sheet.js

@@ -7,7 +7,7 @@
  *   sdlab batch sheet batch_2025-06-30_001 --project star-freight
  */
 
-import { parseArgs } from '../lib/args.js';
+import { parseArgs, getProjectName } from '../lib/args.js';
 import { getProjectRoot } from '../lib/paths.js';
 import { loadBatchManifest } from '../lib/batch-runs.js';
 import { getBatchMode } from '../lib/batch-modes.js';
@@ -20,13 +20,13 @@ import { info } from '../lib/log.js';
 export async function run(argv = process.argv.slice(2)) {
   const { flags, positionals } = parseArgs(argv, {
     flags: {
-      project: { type: 'string', default: 'star-freight' },
+      project: { type: 'string' },
       batch: { type: 'string' },
     },
     deprecated: { game: 'project' },
   });
 
-  const projectName = flags.project;
+  const projectName = flags.project || getProjectName(argv);
   const projectRoot = getProjectRoot(projectName);
   const batchId = positionals[0] || flags.batch;
 

package/scripts/batch-show.js

@@ -9,21 +9,21 @@
  *   sdlab batch show batch_2025-06-30_001 --json     # as JSON
  */
 
-import { parseArgs } from '../lib/args.js';
+import { parseArgs, getProjectName } from '../lib/args.js';
 import { getProjectRoot } from '../lib/paths.js';
 import { listBatches, loadBatchManifest } from '../lib/batch-runs.js';
 
 export async function run(argv = process.argv.slice(2)) {
   const { flags, positionals } = parseArgs(argv, {
     flags: {
-      project: { type: 'string', default: 'star-freight' },
+      project: { type: 'string' },
       batch: { type: 'string' },
       json: { type: 'boolean' },
     },
     deprecated: { game: 'project' },
   });
 
-  const projectName = flags.project;
+  const projectName = flags.project || getProjectName(argv);
   const projectRoot = getProjectRoot(projectName);
   const batchId = positionals[0] || flags.batch;
 

package/scripts/brief-compile.js

@@ -10,7 +10,7 @@
  *   sdlab brief compile --project star-freight --workflow character-portrait-set --subject kael_maren --output-count 8 --json
  */
 
-import { parseArgs } from '../lib/args.js';
+import { parseArgs, getProjectName, parseNumberFlag } from '../lib/args.js';
 import { getProjectRoot } from '../lib/paths.js';
 import { compileBrief, saveCompiledBrief } from '../lib/brief-compiler.js';
 import { info } from '../lib/log.js';
@@ -18,7 +18,7 @@ import { info } from '../lib/log.js';
 export async function run(argv = process.argv.slice(2)) {
   const { flags } = parseArgs(argv, {
     flags: {
-      project: { type: 'string', default: 'star-freight' },
+      project: { type: 'string' },
       workflow: { type: 'string' },
       subject: { type: 'string' },
       asset: { type: 'string' },
@@ -58,7 +58,7 @@ export async function run(argv = process.argv.slice(2)) {
     return;
   }
 
-  const projectName = flags.project;
+  const projectName = flags.project || getProjectName(argv);
   const projectRoot = getProjectRoot(projectName);
 
   // Parse reference IDs
@@ -68,11 +68,11 @@ export async function run(argv = process.argv.slice(2)) {
 
   // Parse overrides
   const overrides = {};
-  if (flags['output-count']) overrides.output_count = parseInt(flags['output-count'], 10);
-  if (flags.width) overrides.width = parseInt(flags.width, 10);
-  if (flags.height) overrides.height = parseInt(flags.height, 10);
-  if (flags.steps) overrides.steps = parseInt(flags.steps, 10);
-  if (flags.cfg) overrides.cfg = parseFloat(flags.cfg);
+  if (flags['output-count']) overrides.output_count = parseNumberFlag('output-count', flags['output-count'], { int: true, min: 1 });
+  if (flags.width) overrides.width = parseNumberFlag('width', flags.width, { int: true, min: 1 });
+  if (flags.height) overrides.height = parseNumberFlag('height', flags.height, { int: true, min: 1 });
+  if (flags.steps) overrides.steps = parseNumberFlag('steps', flags.steps, { int: true, min: 1 });
+  if (flags.cfg) overrides.cfg = parseNumberFlag('cfg', flags.cfg, { min: 0 });
   if (flags.sampler) overrides.sampler = flags.sampler;
   if (flags['seed-mode']) overrides.seed_mode = flags['seed-mode'];
 

package/scripts/brief-show.js

@@ -9,7 +9,7 @@
  *   sdlab brief show brief_2026-04-15_001 --md
  */
 
-import { parseArgs } from '../lib/args.js';
+import { parseArgs, getProjectName } from '../lib/args.js';
 import { getProjectRoot } from '../lib/paths.js';
 import { loadCompiledBrief } from '../lib/brief-compiler.js';
 import { renderBriefText, renderBriefMarkdown } from '../lib/brief-render.js';
@@ -17,7 +17,7 @@ import { renderBriefText, renderBriefMarkdown } from '../lib/brief-render.js';
 export async function run(argv = process.argv.slice(2)) {
   const { flags, positionals } = parseArgs(argv, {
     flags: {
-      project: { type: 'string', default: 'star-freight' },
+      project: { type: 'string' },
       json: { type: 'boolean' },
       md: { type: 'boolean' },
     },
@@ -31,7 +31,8 @@ export async function run(argv = process.argv.slice(2)) {
     return;
   }
 
-  const projectRoot = getProjectRoot(flags.project);
+  const projectName = flags.project || getProjectName(argv);
+  const projectRoot = getProjectRoot(projectName);
   const brief = await loadCompiledBrief(projectRoot, briefId);
 
   if (flags.json) {

package/scripts/canon-bind.js

@@ -21,6 +21,7 @@ import { join } from 'path';
 import { getProjectName } from '../lib/args.js';
 import { REPO_ROOT } from '../lib/paths.js';
 import { loadConstitution, loadLanes, loadRubric, loadTerminology, detectLane, detectGroup } from '../lib/config.js';
+import { inputError, handleCliError } from '../lib/errors.js';
 
 /**
  * Build rationale string from rule's template, interpolating variables.
@@ -162,10 +163,10 @@ export async function run(argv = process.argv.slice(2)) {
 
   // Load project config — fail loudly if missing
   if (!existsSync(join(PROJECT_ROOT, 'constitution.json'))) {
-    throw new Error(
-      `No constitution.json found in ${PROJECT_ROOT}.\n` +
-      `Canon binding requires per-project config files.\n` +
-      `Run: sdlab init ${projectName} --domain <domain>`
+    throw inputError(
+      'INPUT_MISSING_CONFIG',
+      `No constitution.json found in ${PROJECT_ROOT}.`,
+      `Canon binding requires per-project config files. Run: sdlab init ${projectName} --domain <domain>`
     );
   }
 
@@ -175,7 +176,7 @@ export async function run(argv = process.argv.slice(2)) {
   const termConfig = loadTerminology(PROJECT_ROOT);
 
   if (!constitutionConfig.rules || constitutionConfig.rules.length === 0) {
-    throw new Error(`constitution.json has no rules — cannot bind.`);
+    throw inputError('INPUT_EMPTY_CONFIG', `constitution.json has no rules — cannot bind.`);
   }
 
   const constitutionRules = constitutionConfig.rules;
@@ -280,8 +281,5 @@ export async function run(argv = process.argv.slice(2)) {
 
 // Direct execution guard
 if (process.argv[1] && (process.argv[1].endsWith('canon-bind.js') || process.argv[1].endsWith('canon-bind'))) {
-  run().catch((err) => {
-    console.error(err.message || err);
-    process.exit(1);
-  });
+  run().catch(handleCliError);
 }