@mcptoolshop/style-dataset-lab 3.4.0 → 3.5.0

package/scripts/colab/remote_runner.py

@@ -0,0 +1,59 @@
+#!/usr/bin/env python3
+"""Remote kernel runner executed via `colab exec -s <session> -f remote_runner.py`.
+
+Runs the uploaded remote shell script (`SDLAB_REMOTE_SCRIPT`, e.g.
+`/content/remote_lane1_stub.sh` or `/content/remote_lane3_stub.sh`) via
+`subprocess.Popen`, streaming each stdout/stderr line to the IPython kernel's
+stdout as it arrives so the rig's vitals and DEAD HARNESS watcher read it in
+real time, and finishes by printing a `SDLAB_REMOTE_RC=<rc>` marker line.
+"""
+
+from __future__ import annotations
+
+import os
+import shutil
+import subprocess
+import sys
+
+
+def _resolve_bash(env: dict[str, str]) -> str:
+    git_bash = "C:/Program Files/Git/bin/bash.exe"
+    if os.name == "nt" and os.path.exists(git_bash):
+        return git_bash
+    found = shutil.which("bash", path=env.get("PATH"))
+    return found or "bash"
+
+
+def run_remote_script(
+    script_path: str | None = None,
+    *,
+    env: dict[str, str] | None = None,
+) -> int:
+    effective_env = dict(os.environ if env is None else env)
+    target_script = script_path or effective_env.get("SDLAB_REMOTE_SCRIPT", "").strip()
+    if not target_script:
+        print("REFUSED: SDLAB_REMOTE_SCRIPT is required", file=sys.stderr, flush=True)
+        print("SDLAB_REMOTE_RC=2", flush=True)
+        return 2
+
+    cmd = [_resolve_bash(effective_env), target_script]
+    proc = subprocess.Popen(
+        cmd,
+        stdin=subprocess.DEVNULL,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.STDOUT,
+        text=True,
+        bufsize=1,
+        env=effective_env,
+    )
+    assert proc.stdout is not None
+    for line in proc.stdout:
+        sys.stdout.write(line)
+        sys.stdout.flush()
+    rc = int(proc.wait())
+    print(f"SDLAB_REMOTE_RC={rc}", flush=True)
+    return rc
+
+
+if __name__ == "__main__":
+    run_remote_script()

package/scripts/doctor.js

@@ -151,6 +151,7 @@ export async function run(argv = process.argv.slice(2)) {
 
     if (meta.domain) { pass(`project.json: domain = "${meta.domain}"`); passes++; }
     else { warn('project.json: no "domain" set'); warnings++; }
+    if (meta.display_name === 'TEMPLATE') { fail('project.json: display_name is still "TEMPLATE"', 'Set a real display_name in project.json instead of the unedited template placeholder.'); failures++; }
   }
 
   // ── 5. Constitution validation ──

package/scripts/generate.js

@@ -19,8 +19,10 @@ 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 { STUDIO_OWNER, STUDIO_LICENCE, buildDefaultRights } from "../lib/records.js";
+import { resolveCanonLink } from "../lib/generated-provenance.js";
 import { info, result, warn } from "../lib/log.js";
 
 /**
@@ -226,7 +228,7 @@ function findPlaceholderPrompts(jobs) {
  * `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',
@@ -260,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++;
       }
@@ -275,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++;
     }
@@ -384,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.
@@ -399,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++;
@@ -424,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,
         );
@@ -452,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,
@@ -470,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
@@ -490,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/verify.js

@@ -0,0 +1,67 @@
+#!/usr/bin/env node
+
+/**
+ * sdlab verify — Offline end-to-end provenance chain verification (G9, §2.2–§2.3).
+ *
+ * Walks:
+ *   image -> record (G5 owner + CC-BY-4.0)
+ *         -> canon (G6 canon_sha + entry_sha256)
+ *         -> model licence (G4 SPDX id + licence_url + date_read)
+ *         -> run manifest (workflow sha + quarantine guard + verdict separation)
+ */
+
+import { parseArgs, getProjectName } from '../lib/args.js';
+import { getProjectRoot } from '../lib/paths.js';
+import { inputError, handleCliError } from '../lib/errors.js';
+import { verifyProvenanceChain } from '../lib/verify-chain.js';
+
+export async function run(argv = process.argv.slice(2)) {
+  const parsed = parseArgs(argv, {
+    flags: {
+      project: { type: 'string' },
+      game: { type: 'string' },
+      record: { type: 'string' },
+      snapshot: { type: 'string' },
+      json: { type: 'boolean' },
+      'allow-empty': { type: 'boolean' },
+    },
+    deprecated: { game: 'project' },
+  });
+
+  const projectName = getProjectName(argv);
+  const projectDir = getProjectRoot(projectName);
+
+  const report = await verifyProvenanceChain(projectDir, {
+    recordId: parsed.flags.record || null,
+    snapshotId: parsed.flags.snapshot || null,
+    allowEmpty: parsed.flags['allow-empty'] === true,
+  });
+
+  if (parsed.flags.json) {
+    console.log(JSON.stringify(report, null, 2));
+  } else {
+    console.log(`\x1b[1msdlab verify\x1b[0m — ${projectName}`);
+    console.log(`  Records checked: ${report.records_checked} (${report.passed_count} passed, ${report.failed_count} failed)`);
+    for (const f of report.failures) {
+      console.error(`  \x1b[31m✗\x1b[0m [${f.code}] ${f.message}`);
+    }
+    if (report.ok) {
+      console.log(`  \x1b[32m✓\x1b[0m Provenance chain intact (CC-BY-4.0 eligible)`);
+    }
+  }
+
+  if (!report.ok) {
+    const codes = [...new Set(report.failures.map((f) => f.code))].join(', ');
+    throw inputError(
+      'PROVENANCE_VERIFY_FAILED',
+      `Provenance verification failed for project "${projectName}" (${report.failures.length} failure(s): ${codes})`,
+      'Fix the broken provenance link(s) reported above before releasing or exporting under CC-BY-4.0.',
+    );
+  }
+
+  return report;
+}
+
+if (process.argv[1] && (process.argv[1].endsWith('verify.js') || process.argv[1].endsWith('verify'))) {
+  run().catch(handleCliError);
+}