@mcptoolshop/style-dataset-lab 3.3.0 → 3.5.0

package/scripts/generate.js

@@ -14,14 +14,16 @@ import { writeFile, mkdir } from "node:fs/promises";
 import { existsSync } from "node:fs";
 import { join } from "node:path";
 import { parseArgs, getProjectName } from "../lib/args.js";
-import { REPO_ROOT, resolveSafeProjectPath } from "../lib/paths.js";
+import { getProjectRoot, resolveSafeProjectPath } from "../lib/paths.js";
 import { readJsonFile, loadProjectMeta, resolveGpuModel } from "../lib/config.js";
 import { runtimeError, inputError, handleCliError } from "../lib/errors.js";
 import { comfyHealth, submitAndWait, downloadImage } from "../lib/comfyui.js";
 import { pickOutputImage } from "../lib/comfyui-output.js";
-import { buildQwenGraph, QWEN_DEFAULTS } from "../lib/adapters/comfyui-workflows.js";
+import { buildQwenGraph, QWEN_DEFAULTS, resolveQwenLoras } from "../lib/adapters/comfyui-workflows.js";
 import { buildPinning, SEED_POLICIES, createHashCache, flushHashCache } from "../lib/run-manifest.js";
-import { info, result } from "../lib/log.js";
+import { STUDIO_OWNER, STUDIO_LICENCE, buildDefaultRights } from "../lib/records.js";
+import { resolveCanonLink } from "../lib/generated-provenance.js";
+import { info, result, warn } from "../lib/log.js";
 
 /**
  * Format milliseconds as a human ETA string like "6m 12s" or "42s".
@@ -179,6 +181,34 @@ function buildWorkflow(prompt, negativePrompt, checkpoint, loras, seed, steps, c
   return { nodes, saveNodeId: saveId };
 }
 
+/**
+ * Coordinator addendum (same session as H4/H5): every domain template's
+ * example-wave.json ships subject prompts with a literal `[DESCRIBE ...]`
+ * placeholder (e.g. "[DESCRIBE YOUR HERO — head and shoulders, ...]") that
+ * the user is meant to replace before generating. `sdlab init`'s own
+ * printed next-steps run generate before "edit the pack" is ever a
+ * mandatory step, so following them literally on an unedited pack burns a
+ * GPU wave on template text with no feedback until the images come back
+ * looking like a literal instruction string.
+ *
+ * All 5 domain templates use this exact "[DESCRIBE " shape (verified across
+ * templates/domains/*\/inputs/prompts/example-wave.json), so the check is
+ * narrow and specific to it — it does NOT flag ordinary SD prompt-editing
+ * bracket syntax such as "[word]" or "[from:to:0.5]", neither of which
+ * starts with the literal word DESCRIBE.
+ */
+const PLACEHOLDER_PROMPT_RE = /\[DESCRIBE\b/;
+
+function findPlaceholderPrompts(jobs) {
+  const hits = [];
+  for (const job of jobs) {
+    if (typeof job.prompt === 'string' && PLACEHOLDER_PROMPT_RE.test(job.prompt)) {
+      hits.push(job.assetId);
+    }
+  }
+  return hits;
+}
+
 /**
  * Detect the input schema and normalize to a unified shape:
  *   { lane, style_prefix, negative, defaults, base, jobs:[{assetId, subjectId, variationId, prompt, seed, loras}] }
@@ -198,7 +228,7 @@ function buildWorkflow(prompt, negativePrompt, checkpoint, loras, seed, steps, c
  * `base` resolves: input.base → input.defaults.base → project.json defaults.base
  * → "sdxl". `"qwen-image"` routes to the non-anime Qwen graph.
  */
-function normalizeGenerationInput(raw, projectMeta) {
+export function normalizeGenerationInput(raw, projectMeta) {
   if (!Array.isArray(raw.subjects) || raw.subjects.length === 0) {
     throw inputError(
       'INPUT_MISSING_FIELDS',
@@ -232,10 +262,11 @@ function normalizeGenerationInput(raw, projectMeta) {
         jobs.push({
           assetId: `${subject.id}_${variation.id}`,
           subjectId: subject.id,
+          entryId: subject.entry_id || subject.id,
           variationId: variation.id,
           prompt: compose(subject.prompt),
           seed: baseSeed + k + (variation.seed_offset || 0),
-          loras: variation.loras || [],
+          loras: variation.loras || subject.loras || [],
         });
         k++;
       }
@@ -247,14 +278,16 @@ function normalizeGenerationInput(raw, projectMeta) {
   const negative = raw.negative ?? defaults.negative ?? '';
   for (const subject of raw.subjects) {
     const nvar = Number.isFinite(subject.variations) ? subject.variations : 1;
+    const subjectLoras = subject.loras || defaults.loras || raw.loras || [];
     for (let v = 0; v < nvar; v++) {
       jobs.push({
         assetId: `${subject.id}_v${v}`,
         subjectId: subject.id,
+        entryId: subject.entry_id || subject.id,
         variationId: `v${v}`,
         prompt: compose(subject.prompt),
         seed: baseSeed + k,
-        loras: [],
+        loras: subjectLoras,
       });
       k++;
     }
@@ -264,7 +297,7 @@ function normalizeGenerationInput(raw, projectMeta) {
 
 export async function run(argv = process.argv.slice(2)) {
   const projectName = getProjectName(argv);
-  const GAME_ROOT = join(REPO_ROOT, 'projects', projectName);
+  const GAME_ROOT = getProjectRoot(projectName);
   const COMFY_URL = process.env.COMFY_URL || "http://127.0.0.1:8188";
 
   const parsed = parseArgs(argv, {
@@ -323,6 +356,17 @@ export async function run(argv = process.argv.slice(2)) {
   console.log(`  Total candidates: ${pack.jobs.length}`);
   console.log("");
 
+  // Coordinator addendum: catch unedited template text before it burns GPU
+  // time (or, under --dry-run, before the user thinks the pack is ready).
+  const placeholderHits = findPlaceholderPrompts(pack.jobs);
+  if (placeholderHits.length > 0) {
+    warn(
+      `${placeholderHits.length} of ${pack.jobs.length} prompt(s) still contain unedited "[DESCRIBE ...]" template ` +
+      `text (e.g. "${placeholderHits[0]}"). Edit the prompt pack before generating for real — otherwise you'll spend ` +
+      `GPU time rendering placeholder instructions instead of your subject.`
+    );
+  }
+
   if (!dryRun) {
     const online = await comfyHealth(COMFY_URL);
     if (!online) {
@@ -331,8 +375,12 @@ export async function run(argv = process.argv.slice(2)) {
     console.log("\x1b[32m✓\x1b[0m ComfyUI online");
   }
 
-  await mkdir(join(GAME_ROOT, "outputs/candidates"), { recursive: true });
-  await mkdir(join(GAME_ROOT, "records"), { recursive: true });
+  // SDL-M11: only create output dirs on a real run — a --dry-run preview must
+  // be side-effect-free (README.md promises "preview the effect first").
+  if (!dryRun) {
+    await mkdir(join(GAME_ROOT, "outputs/candidates"), { recursive: true });
+    await mkdir(join(GAME_ROOT, "records"), { recursive: true });
+  }
 
   let generated = 0;
   let errors = 0;
@@ -341,7 +389,10 @@ export async function run(argv = process.argv.slice(2)) {
   const runStartMs = Date.now();
 
   for (const job of pack.jobs) {
-    const { assetId, prompt: fullPrompt, seed, loras } = job;
+    const { assetId, entryId, prompt: fullPrompt, seed, loras } = job;
+    const effectiveLoras = isQwen
+      ? resolveQwenLoras({ projectDefaults: d, loras })
+      : loras;
 
     // --resume: skip jobs whose record + image are both already on disk.
     // Seeds are precomputed per job index, so skipping never shifts later seeds.
@@ -356,7 +407,7 @@ export async function run(argv = process.argv.slice(2)) {
       }
     }
 
-    console.log(`  [${generated + 1}/${totalExpected}] ${assetId} (seed: ${seed}, loras: ${isQwen ? (d.loras || []).length : loras.length})`);
+    console.log(`  [${generated + 1}/${totalExpected}] ${assetId} (seed: ${seed}, loras: ${effectiveLoras.length})`);
 
     if (dryRun) {
       generated++;
@@ -381,12 +432,12 @@ export async function run(argv = process.argv.slice(2)) {
           vae: d.vae || QWEN_DEFAULTS.vae,
           clipType: d.clip_type || QWEN_DEFAULTS.clip_type,
           weightDtype: d.weight_dtype || QWEN_DEFAULTS.weight_dtype,
-          loras: d.loras || [],
+          loras: effectiveLoras,
           filenamePrefix: 'sdl',
         })
       : buildWorkflow(
           fullPrompt, pack.negative,
-          d.checkpoint, loras, seed,
+          d.checkpoint, effectiveLoras, seed,
           resolved.steps, resolved.cfg, resolved.sampler, resolved.scheduler,
           resolved.width, resolved.height,
         );
@@ -409,9 +460,16 @@ export async function run(argv = process.argv.slice(2)) {
       const destPath = `outputs/candidates/${assetId}.png`;
       await writeFile(join(GAME_ROOT, destPath), imgData);
 
+      const canonLink = resolveCanonLink(GAME_ROOT, {
+        canonSha: raw.canon_sha || null,
+        entryId,
+      });
+
       // Write provenance record (base-aware: Qwen records unet/clip/vae/shift,
       // SDXL records checkpoint/loras).
       const provenance = {
+        owner: STUDIO_OWNER,
+        licence: STUDIO_LICENCE,
         workflow_id: pack.lane,
         workflow_version: "1.0.0",
         base,
@@ -427,16 +485,23 @@ export async function run(argv = process.argv.slice(2)) {
         generation_time_ms: elapsed,
         gpu_model: gpuModel,
         batch_index: generated,
+        ...(canonLink
+          ? {
+              canon_sha: canonLink.canon_sha,
+              entry_id: canonLink.entry_id,
+              entry_sha256: canonLink.entry_sha256,
+            }
+          : {}),
       };
       if (isQwen) {
         provenance.unet = d.unet || QWEN_DEFAULTS.unet;
         provenance.clip = d.clip || QWEN_DEFAULTS.clip;
         provenance.vae = d.vae || QWEN_DEFAULTS.vae;
         provenance.shift = d.shift ?? QWEN_DEFAULTS.shift;
-        provenance.loras = d.loras || [];
+        provenance.loras = effectiveLoras;
       } else {
         provenance.checkpoint = d.checkpoint;
-        provenance.loras = loras;
+        provenance.loras = effectiveLoras;
       }
 
       // PIN_PER_STEP: pin the exact graph + model/LoRA content identity + seed
@@ -447,21 +512,25 @@ export async function run(argv = process.argv.slice(2)) {
         models: isQwen
           ? { unet: provenance.unet, clip: provenance.clip, vae: provenance.vae }
           : { checkpoint: d.checkpoint },
-        loras: isQwen ? (d.loras || []) : loras,
+        loras: effectiveLoras,
         seedPolicy: SEED_POLICIES.BASE_INCREMENT,
         hashModels,
         cache: hashCache,
       });
+      provenance.comfy_workflow_sha = provenance.pinning.comfy_workflow_sha;
 
       const record = {
         id: assetId,
         schema_version: "1.0.0",
         created_at: new Date().toISOString(),
+        owner: STUDIO_OWNER,
+        licence: STUDIO_LICENCE,
+        rights: buildDefaultRights(),
         asset_path: destPath,
         image: { format: "png", width: resolved.width, height: resolved.height, bytes: imgData.length },
         provenance,
         judgment: null,
-        canon: null,
+        canon: canonLink,
         iteration: null,
       };
 

package/scripts/implementation-pack.js

@@ -11,7 +11,7 @@
 
 import { join } from 'node:path';
 import { parseArgs, getProjectName } from '../lib/args.js';
-import { REPO_ROOT } from '../lib/paths.js';
+import { getProjectRoot } from '../lib/paths.js';
 import { inputError, handleCliError } from '../lib/errors.js';
 import { listTrainingManifests } from '../lib/training-manifests.js';
 import { buildImplementationPack, listImplementationPacks, loadImplementationPack } from '../lib/implementation-packs.js';
@@ -26,7 +26,7 @@ export async function run(argv = process.argv.slice(2)) {
   });
 
   const projectName = flags.project || getProjectName(argv);
-  const projectRoot = join(REPO_ROOT, 'projects', projectName);
+  const projectRoot = getProjectRoot(projectName);
   const subcommand = positionals.find(a => !a.startsWith('impl-') && !a.startsWith('tm-')) || 'list';
 
   if (subcommand === 'build') {

package/scripts/ingest.js

@@ -0,0 +1,145 @@
+#!/usr/bin/env node
+
+/**
+ * ingest.js — Bring a directory of pre-existing images into the pipeline
+ * as bare, uncurated candidate records.
+ *
+ * Closes the gap where generation happened OUTSIDE sdlab entirely (a hand
+ * batch, external Python against Comfy Cloud, salvage from somewhere else)
+ * and there was no CLI path to get those images into records/ for review.
+ * Unlike `sdlab reingest generated` (which requires a trained LoRA's
+ * training manifest) or `sdlab reingest selected` (which requires a
+ * selection id only the production loop can mint), this takes any folder
+ * of images and any project — no pipeline history required.
+ *
+ * Usage:
+ *   sdlab ingest <dir> --project <name>
+ *   sdlab ingest <dir> --project <name> --wave inputs/prompts/wave-v2.json
+ *   sdlab ingest <dir> --project <name> --dry-run
+ *   sdlab ingest <dir> --project <name> --json
+ */
+
+import { parseArgs, getProjectName } from '../lib/args.js';
+import { REPO_ROOT, getProjectRoot, resolveSafeProjectPath } from '../lib/paths.js';
+import { inputError, handleCliError } from '../lib/errors.js';
+import { ingestDirectory } from '../lib/ingest.js';
+import { result } from '../lib/log.js';
+
+const USAGE = `Usage: sdlab ingest <dir> --project <name> [--wave <wave.json>] [--dry-run] [--json]
+
+Scan <dir> for images and create bare candidate records (judgment: null,
+canon: null, provenance.source: "external") ready for "sdlab curate".
+
+Positional:
+  dir                  Directory of images to ingest (png/jpg/jpeg/webp)
+
+Flags:
+  --project <name>     Project to operate on
+  --wave <path>        Optional wave JSON (inputs/prompts/*.json shape) to
+                        attach real generation provenance (seed, prompt, ...)
+                        by matching each image's filename stem to an item id.
+                        A sibling receipts.jsonl next to <dir> is picked up
+                        automatically when present (prompt_id, seconds, status).
+  --dry-run            Preview what would be created — no files written
+  --json               Emit the result as JSON on stdout
+
+Next steps after ingesting:
+  1. Review: sdlab curate <id> approved/rejected "explanation"
+  2. Bind:   sdlab bind --project <name>`;
+
+export async function run(argv = process.argv.slice(2)) {
+  if (argv.includes('--help') || argv.includes('-h')) {
+    console.log(USAGE);
+    return;
+  }
+
+  const { flags, positionals } = parseArgs(argv, {
+    flags: {
+      project: { type: 'string' },
+      wave: { type: 'string' },
+      'dry-run': { type: 'boolean', default: false },
+      json: { type: 'boolean', default: false },
+    },
+    deprecated: { game: 'project' },
+  });
+
+  const dirArg = positionals[0];
+  if (!dirArg) {
+    throw inputError(
+      'INPUT_MISSING_ARGS',
+      'A source directory is required.',
+      USAGE
+    );
+  }
+
+  const projectName = flags.project || getProjectName(argv);
+  const projectRoot = getProjectRoot(projectName);
+  const dryRun = flags['dry-run'] || flags.dryRun;
+
+  // Mirrors scripts/reingest.js's --source handling: the source directory
+  // of pre-existing images is allowed to live anywhere under the workspace
+  // root, not just inside this specific project (e.g. a shared staging
+  // inbox), while still refusing to escape the workspace entirely.
+  const safeSourceDir = resolveSafeProjectPath(projectRoot, dirArg, { baseRoot: REPO_ROOT, flagName: 'dir' });
+
+  // Mirrors scripts/generate.js's pack-path handling: a --wave file is
+  // expected to live inside THIS project (inputs/prompts/*.json), so its
+  // containment root defaults to the project root, not the whole workspace.
+  const safeWavePath = flags.wave
+    ? resolveSafeProjectPath(projectRoot, flags.wave, { flagName: 'wave' })
+    : null;
+
+  if (!flags.json) {
+    console.log(`\x1b[1msdlab ingest\x1b[0m — ${projectName}`);
+    console.log(`  Source: ${dirArg}`);
+    if (flags.wave) console.log(`  Wave:   ${flags.wave}`);
+    if (dryRun) console.log(`  Mode:   DRY RUN (no files written)`);
+    console.log('');
+  }
+
+  const { created, skipped, rejected, receiptsFile } = await ingestDirectory(projectRoot, safeSourceDir, {
+    wavePath: safeWavePath,
+    dryRun,
+  });
+
+  if (flags.json) {
+    console.log(JSON.stringify({ created, skipped, rejected, receiptsFile, dryRun }, null, 2));
+    return;
+  }
+
+  if (receiptsFile) {
+    console.log(`  \x1b[2mreceipts: ${receiptsFile}\x1b[0m`);
+  }
+
+  console.log(`  \x1b[32m✓\x1b[0m Created: ${created.length} record(s)${dryRun ? ' (dry run — nothing written)' : ''}`);
+  if (created.length > 0 && created.length <= 25) {
+    for (const id of created) console.log(`    ✓ ${id}`);
+  }
+
+  if (skipped.length > 0) {
+    console.log(`  Skipped: ${skipped.length} (record already exists)`);
+    if (skipped.length <= 25) {
+      for (const id of skipped) console.log(`    ○ ${id}`);
+    }
+  }
+
+  if (rejected.length > 0) {
+    console.log(`  \x1b[33m⚠\x1b[0m Rejected: ${rejected.length} (unsafe id derived from filename — rename and re-run)`);
+    for (const r of rejected) console.log(`    ✗ ${r.file}: ${r.reason}`);
+  }
+
+  if (!dryRun && created.length > 0) {
+    console.log('');
+    result(`Candidates: outputs/candidates/`);
+    result(`Records: records/`);
+    console.log('');
+    console.log('  Next steps:');
+    console.log('    1. Review: sdlab curate <id> approved/rejected "explanation"');
+    console.log('    2. Bind:   sdlab bind --project ' + projectName);
+  }
+}
+
+// Direct execution guard
+if (process.argv[1] && (process.argv[1].endsWith('ingest.js') || process.argv[1].endsWith('ingest'))) {
+  run().catch(handleCliError);
+}

package/scripts/init.js

@@ -12,10 +12,16 @@
 import { mkdir, readdir, readFile, writeFile, copyFile } from 'node:fs/promises';
 import { join, basename } from 'node:path';
 import { existsSync } from 'node:fs';
-import { REPO_ROOT } from '../lib/paths.js';
+import { REPO_ROOT, getPackageRoot } from '../lib/paths.js';
 import { inputError, handleCliError } from '../lib/errors.js';
+import { takeFlagValue } from '../lib/args.js';
 
-const TEMPLATES_DIR = join(REPO_ROOT, 'templates');
+// Two DIFFERENT roots — see getPackageRoot() in lib/paths.js.
+// `templates/` ships inside the npm tarball, so it is package-relative;
+// `projects/` is the user's own work, so it is workspace-relative. In a repo
+// checkout these coincide, which is why resolving both against REPO_ROOT
+// passed every in-repo test while breaking `init` for every installed user.
+const TEMPLATES_DIR = join(getPackageRoot(), 'templates');
 const PROJECTS_DIR = join(REPO_ROOT, 'projects');
 
 const PROJECT_DIRS = [
@@ -64,11 +70,15 @@ async function listDomains() {
 export async function run(argv = process.argv.slice(2)) {
   const projectName = argv.find(a => !a.startsWith('--'));
 
-  // Parse --domain
+  // Parse --domain. H4: previously a hand-rolled `argv.indexOf('--domain')`
+  // that only recognized the space-separated form — `sdlab init foo
+  // --domain=game-art` silently fell through to the 'generic' default
+  // because no argv token was EXACTLY "--domain". takeFlagValue() (already
+  // hardened for both `--flag value` and `--flag=value`) closes that gap.
   let domain = 'generic';
-  const domainIdx = argv.indexOf('--domain');
-  if (domainIdx >= 0 && argv[domainIdx + 1]) {
-    domain = argv[domainIdx + 1];
+  const domainValue = takeFlagValue(argv, 'domain');
+  if (domainValue !== undefined) {
+    domain = domainValue;
   }
 
   if (!projectName) {
@@ -133,6 +143,34 @@ export async function run(argv = process.argv.slice(2)) {
   }
   console.log(`  \x1b[32m✓\x1b[0m Created ${PROJECT_DIRS.length} directories`);
 
+  // SDL-M6: the generate → curate → reingest loop fills inbox/generated/ and
+  // the outputs/ subtrees with PNGs (see lib/reingest-selected.js), but this
+  // repo's OWN .gitignore (which happens to cover those paths in dev) is not
+  // in the npm `files` allow-list and ships to nobody. Without a per-project
+  // .gitignore, every downstream `sdlab init` user stages regenerable blobs
+  // by construction — measured at 55 MB of untracked PNGs in this repo before
+  // this fix. Never clobber a .gitignore the user already created by hand.
+  const gitignorePath = join(projectDir, '.gitignore');
+  if (!existsSync(gitignorePath)) {
+    const gitignoreLines = [
+      '# Generated by `sdlab init` — regenerable blobs for this project.',
+      '# Records/config JSON are tracked; only pixels and derived artifacts are not.',
+      '',
+      'inbox/**/*.png',
+      'inbox/**/*.jpg',
+      'inbox/**/*.jpeg',
+      'inbox/**/*.webp',
+      'outputs/**',
+      'exports/',
+      'snapshots/',
+      'splits/',
+      'canon-build/*/',
+      '',
+    ];
+    await writeFile(gitignorePath, gitignoreLines.join('\n'));
+    console.log(`  \x1b[32m✓\x1b[0m .gitignore (regenerable outputs/inbox/exports/snapshots/splits)`);
+  }
+
   // Copy config files from domain template or generate generic ones
   const configFiles = ['project.json', 'constitution.json', 'lanes.json', 'rubric.json', 'terminology.json'];
 
@@ -331,21 +369,43 @@ export async function run(argv = process.argv.slice(2)) {
   console.log('');
   console.log(`\x1b[32m✓\x1b[0m Project "${projectName}" initialized`);
   console.log('');
+  // Two DIFFERENT path bases are printed in this block, for two DIFFERENT
+  // audiences — do not collapse them back into one helper:
+  //   - "Edit <file>" / "Full quick-start" lines are opened by the user in
+  //     an editor/file-browser from wherever they ran `init` (the workspace
+  //     root), so they need workspace-relative paths: projects/<name>/....
+  //   - The `sdlab generate <pack>` line's argument is consumed by
+  //     generate.js via resolveSafeProjectPath(GAME_ROOT, packPath) — GAME_ROOT
+  //     IS projects/<name>, so that path must be PROJECT-relative
+  //     (inputs/prompts/...), not workspace-relative. Printing the
+  //     workspace-relative form here doubles the path
+  //     (projects/<name>/projects/<name>/...) and generate.js 404s with
+  //     INPUT_FILE_NOT_FOUND. Regression introduced in 27c42c6 while fixing
+  //     the sibling "Edit" lines (which legitimately needed the workspace-
+  //     relative switch) — see tests/cli-scripts/init-generate-path.test.js.
+  const rel = (...segments) => ['projects', projectName, ...segments].join('/');
+  const projectRel = (...segments) => segments.join('/');
+
   console.log('Next steps:');
   let step = 1;
   if (wroteCanon['constitution.md']) {
-    console.log(`  ${step++}. Edit ${projectName}/canon/constitution.md — define your visual rules`);
+    console.log(`  ${step++}. Edit ${rel('canon', 'constitution.md')}`);
+    console.log(`     Describe your visual rules in prose — this is the canon the pipeline binds to.`);
   }
-  console.log(`  ${step++}. Edit ${projectName}/constitution.json — encode rules for canon-bind`);
+  console.log(`  ${step++}. Edit ${rel('constitution.json')}`);
+  console.log(`     Encode those rules as machine-checkable entries for canon-bind.`);
   if (wroteExamplePack) {
-    console.log(`  ${step++}. Run: sdlab generate inputs/prompts/example-wave.json --project ${projectName}`);
+    console.log(`  ${step++}. Generate your first candidates:`);
+    console.log(`     sdlab generate ${projectRel('inputs', 'prompts', 'example-wave.json')} --project ${projectName}`);
   } else {
-    console.log(`  ${step++}. Create prompt packs under ${projectName}/inputs/prompts/`);
-    console.log(`  ${step++}. Run: sdlab generate <pack> --project ${projectName}`);
+    console.log(`  ${step++}. Add a prompt pack under ${rel('inputs', 'prompts')}/`);
+    console.log(`  ${step++}. Generate your first candidates:`);
+    console.log(`     sdlab generate <pack> --project ${projectName}`);
   }
-  console.log(`  ${step++}. Run: sdlab project doctor --project ${projectName}`);
+  console.log(`  ${step++}. Check the project is wired correctly:`);
+  console.log(`     sdlab project doctor --project ${projectName}`);
   console.log('');
-  console.log(`See ${projectName}/README.md for the full quick-start.`);
+  console.log(`Full quick-start: ${rel('README.md')}`);
 }
 
 // Direct execution guard