pixelkiln 0.15.0 → 0.16.0

package/dist/cli.js

@@ -1,9 +1,9 @@
 #!/usr/bin/env node
 
 // src/cli.ts
-import path23 from "path";
-import { existsSync as existsSync18 } from "fs";
-import { readFile as readFile17 } from "fs/promises";
+import path24 from "path";
+import { existsSync as existsSync19 } from "fs";
+import { readFile as readFile18 } from "fs/promises";
 
 // src/env.ts
 import { readFileSync, existsSync } from "fs";
@@ -114,10 +114,10 @@ import { createReadStream } from "fs";
 function sha256(data) {
   return createHash("sha256").update(data).digest("hex");
 }
-async function sha256File(path24) {
+async function sha256File(path25) {
   return new Promise((resolve, reject) => {
     const hash = createHash("sha256");
-    const stream = createReadStream(path24);
+    const stream = createReadStream(path25);
     stream.on("data", (chunk2) => hash.update(chunk2));
     stream.on("error", reject);
     stream.on("end", () => resolve(hash.digest("hex")));
@@ -148,7 +148,14 @@ function specHash(spec, styleImageHashes, providerOptionIdentity = spec.provider
       tileView: spec.tileView,
       tileFeature: spec.tileFeature,
       outlineMode: spec.outlineMode,
-      styleImages: styleImageHashes
+      styleImages: styleImageHashes,
+      revision: spec.revision ? {
+        mode: spec.revision.mode,
+        from: spec.revision.sourceAssetId,
+        sourceSha256: spec.revision.sourceSha256,
+        maskSha256: spec.revision.maskSha256,
+        strength: spec.revision.strength
+      } : void 0
     })
   );
 }
@@ -623,6 +630,37 @@ var ComfyUIClient = class {
     }
     return promptId;
   }
+  async uploadImage(bytes, sha2562, format) {
+    const extension = format === "jpeg" ? "jpg" : "png";
+    const form = new FormData();
+    form.append(
+      "image",
+      new Blob([new Uint8Array(bytes)], { type: format === "jpeg" ? "image/jpeg" : "image/png" }),
+      `${sha2562}.${extension}`
+    );
+    form.append("type", "input");
+    form.append("subfolder", "pixelkiln");
+    form.append("overwrite", "true");
+    const url = this.endpoint("upload/image");
+    const response = await this.request(url, { method: "POST", body: form });
+    const text = await response.text();
+    let value = null;
+    try {
+      value = text ? JSON.parse(text) : null;
+    } catch {
+      value = null;
+    }
+    if (!response.ok) {
+      throw new Error(
+        `ComfyUI image upload failed (${response.status})` + (apiError(value) ? `: ${apiError(value)}` : "")
+      );
+    }
+    if (!isObject(value) || typeof value.name !== "string" || !value.name) {
+      throw new Error("ComfyUI image upload returned an invalid response");
+    }
+    const subfolder = typeof value.subfolder === "string" ? value.subfolder : "";
+    return subfolder ? `${subfolder.replace(/\/+$/, "")}/${value.name}` : value.name;
+  }
   async history(promptId) {
     return this.json(`history/${encodeURIComponent(promptId)}`);
   }
@@ -718,11 +756,15 @@ var ComfyUIProvider = class _ComfyUIProvider {
   supports(generator) {
     return generator === "map";
   }
+  supportsRevision(_mode) {
+    return true;
+  }
   estimate(spec) {
     return { unit: "free", amount: 0, candidates: resolvedOptions(spec).numImages };
   }
   validate(spec, styleImages) {
     const options = resolvedOptions(spec);
+    if (spec.source && !spec.revision) return;
     if (spec.width < 16 || spec.height < 16 || spec.width > 4096 || spec.height > 4096) {
       throw new Error("ComfyUI output dimensions must be between 16 and 4096 pixels");
     }
@@ -735,6 +777,31 @@ var ComfyUIProvider = class _ComfyUIProvider {
     if (spec.seed != null && !options.bindings.seed) {
       throw new Error("ComfyUI requires bindings.seed when the style declares a seed");
     }
+    if (!options.bindings.width !== !options.bindings.height) {
+      throw new Error("ComfyUI width and height bindings must be declared together");
+    }
+    if (!spec.revision && (!options.bindings.width || !options.bindings.height)) {
+      throw new Error("ComfyUI text-to-image generation requires width and height bindings");
+    }
+    if (options.numImages > 1 && !options.bindings.batchSize) {
+      throw new Error("ComfyUI numImages greater than 1 requires bindings.batchSize");
+    }
+    if (spec.revision) {
+      if (!options.bindings.sourceImage) {
+        throw new Error("ComfyUI revisions require bindings.sourceImage");
+      }
+      if (spec.revision.mode === "inpaint" && !options.bindings.maskImage) {
+        throw new Error("ComfyUI inpaint revisions require bindings.maskImage");
+      }
+      if (spec.revision.strength != null && !options.bindings.strength) {
+        throw new Error("ComfyUI revision strength requires bindings.strength");
+      }
+      if ((!options.bindings.width || !options.bindings.height) && spec.revision.sourceWidth != null && spec.revision.sourceHeight != null && (spec.width !== spec.revision.sourceWidth || spec.height !== spec.revision.sourceHeight)) {
+        throw new Error(
+          "ComfyUI revisions without width/height bindings must keep the source dimensions"
+        );
+      }
+    }
     validateWorkflowBindings(options.workflow, options);
   }
   rateLimit() {
@@ -745,14 +812,61 @@ var ComfyUIProvider = class _ComfyUIProvider {
     const options = resolvedOptions(spec);
     const workflow = structuredClone(options.workflow);
     setBinding(workflow, options.bindings.prompt, spec.prompt);
-    setBinding(workflow, options.bindings.width, spec.width);
-    setBinding(workflow, options.bindings.height, spec.height);
-    setBinding(workflow, options.bindings.batchSize, options.numImages);
+    if (options.bindings.width) setBinding(workflow, options.bindings.width, spec.width);
+    if (options.bindings.height) setBinding(workflow, options.bindings.height, spec.height);
+    if (options.bindings.batchSize) {
+      setBinding(workflow, options.bindings.batchSize, options.numImages);
+    }
     if (spec.seed != null && options.bindings.seed) {
       setBinding(workflow, options.bindings.seed, spec.seed);
     }
+    if (spec.revision) {
+      if (!spec.revision.sourceSha256 || !spec.revision.sourceFormat) {
+        throw new Error("ComfyUI revision source is not ready");
+      }
+      const sourceBytes = await readFile(spec.revision.sourceFile);
+      if (sha256(sourceBytes) !== spec.revision.sourceSha256) {
+        throw new Error("ComfyUI revision source changed before upload");
+      }
+      const uploadedSource = await this.client.uploadImage(
+        sourceBytes,
+        spec.revision.sourceSha256,
+        spec.revision.sourceFormat
+      );
+      setBinding(workflow, options.bindings.sourceImage, uploadedSource);
+      if (spec.revision.maskFile) {
+        if (!spec.revision.maskSha256 || !spec.revision.maskFormat) {
+          throw new Error("ComfyUI revision mask is not ready");
+        }
+        const maskBytes = await readFile(spec.revision.maskFile);
+        if (sha256(maskBytes) !== spec.revision.maskSha256) {
+          throw new Error("ComfyUI revision mask changed before upload");
+        }
+        const uploadedMask = await this.client.uploadImage(
+          maskBytes,
+          spec.revision.maskSha256,
+          spec.revision.maskFormat
+        );
+        setBinding(workflow, options.bindings.maskImage, uploadedMask);
+      }
+      if (spec.revision.strength != null) {
+        setBinding(workflow, options.bindings.strength, spec.revision.strength);
+      }
+    }
     const promptId = await this.client.submit(workflow);
-    return { jobId: encodeJob(promptId, options.outputNodeId) };
+    return {
+      jobId: encodeJob(promptId, options.outputNodeId),
+      ...spec.revision ? {
+        metadata: {
+          revision: {
+            mode: spec.revision.mode,
+            sourceAssetId: spec.revision.sourceAssetId,
+            sourceSha256: spec.revision.sourceSha256,
+            ...spec.revision.maskSha256 ? { maskSha256: spec.revision.maskSha256 } : {}
+          }
+        }
+      } : {}
+    };
   }
   async poll(jobId, _generator, context) {
     const { promptId, outputNodeId } = decodeJob(jobId);
@@ -827,15 +941,27 @@ function parseOptions(value) {
     throw new Error("ComfyUI numImages must be a whole number from 1 to 16");
   }
   if (!isObject(value.bindings)) throw new Error("ComfyUI bindings must be an object");
-  const bindingKeys = /* @__PURE__ */ new Set(["prompt", "width", "height", "batchSize", "seed"]);
+  const bindingKeys = /* @__PURE__ */ new Set([
+    "prompt",
+    "width",
+    "height",
+    "batchSize",
+    "seed",
+    "sourceImage",
+    "maskImage",
+    "strength"
+  ]);
   const extraBindings = Object.keys(value.bindings).filter((key) => !bindingKeys.has(key));
   if (extraBindings.length) throw new Error(`Unknown ComfyUI binding(s): ${extraBindings.join(", ")}`);
   const bindings = {
     prompt: parseBinding(value.bindings.prompt, "prompt"),
-    width: parseBinding(value.bindings.width, "width"),
-    height: parseBinding(value.bindings.height, "height"),
-    batchSize: parseBinding(value.bindings.batchSize, "batchSize"),
-    ...value.bindings.seed == null ? {} : { seed: parseBinding(value.bindings.seed, "seed") }
+    ...value.bindings.width == null ? {} : { width: parseBinding(value.bindings.width, "width") },
+    ...value.bindings.height == null ? {} : { height: parseBinding(value.bindings.height, "height") },
+    ...value.bindings.batchSize == null ? {} : { batchSize: parseBinding(value.bindings.batchSize, "batchSize") },
+    ...value.bindings.seed == null ? {} : { seed: parseBinding(value.bindings.seed, "seed") },
+    ...value.bindings.sourceImage == null ? {} : { sourceImage: parseBinding(value.bindings.sourceImage, "sourceImage") },
+    ...value.bindings.maskImage == null ? {} : { maskImage: parseBinding(value.bindings.maskImage, "maskImage") },
+    ...value.bindings.strength == null ? {} : { strength: parseBinding(value.bindings.strength, "strength") }
   };
   const workflow = value.workflow == null ? void 0 : parseWorkflow(value.workflow, workflowFile);
   const workflowSha256 = value.workflowSha256 == null ? void 0 : requiredString(value.workflowSha256, "workflowSha256");
@@ -928,7 +1054,16 @@ function comfyMetadata(spec, promptId, outputNodeId, images) {
     outputCount: images.length,
     workflowFile: options.workflowFile,
     workflowSha256: options.workflowSha256,
-    files: images.map((image) => ({ ...image }))
+    files: images.map((image) => ({ ...image })),
+    ...spec.revision ? {
+      revision: {
+        mode: spec.revision.mode,
+        sourceAssetId: spec.revision.sourceAssetId,
+        sourceSha256: spec.revision.sourceSha256,
+        ...spec.revision.maskSha256 ? { maskSha256: spec.revision.maskSha256 } : {},
+        ...spec.revision.strength == null ? {} : { strength: spec.revision.strength }
+      }
+    } : {}
   };
 }
 function encodeJob(promptId, outputNodeId) {
@@ -1129,11 +1264,11 @@ var PixelLabClient = class {
    * common than the failure mode of retrying (a duplicate object), and a
    * duplicate is visible and free to delete whereas a silent gap is neither.
    */
-  async request(path24, init, attempt = 0) {
+  async request(path25, init, attempt = 0) {
     const auth = this.apiKey.startsWith("Bearer ") ? this.apiKey : `Bearer ${this.apiKey}`;
     let res;
     try {
-      res = await fetch(`${BASE}${path24}`, {
+      res = await fetch(`${BASE}${path25}`, {
         ...init,
         signal: init?.signal ?? AbortSignal.timeout(this.timeoutMs),
         headers: {
@@ -1145,24 +1280,24 @@ var PixelLabClient = class {
     } catch (err) {
       if (attempt < MAX_RETRIES) {
         await sleep(backoffMs(attempt));
-        return this.request(path24, init, attempt + 1);
+        return this.request(path25, init, attempt + 1);
       }
       throw err;
     }
     if (!res.ok && shouldRetry(res.status) && attempt < MAX_RETRIES) {
       const waitMs = retryAfterMs(res.headers.get("retry-after")) ?? backoffMs(attempt);
       await sleep(waitMs);
-      return this.request(path24, init, attempt + 1);
+      return this.request(path25, init, attempt + 1);
     }
     const text = await res.text();
     if (!res.ok) {
-      throw new PixelLabError(`${init?.method ?? "GET"} ${path24} \u2192 ${res.status}`, res.status, text);
+      throw new PixelLabError(`${init?.method ?? "GET"} ${path25} \u2192 ${res.status}`, res.status, text);
     }
     if (!text) return {};
     try {
       return JSON.parse(text);
     } catch {
-      throw new Error(`${init?.method ?? "GET"} ${path24} returned invalid JSON`);
+      throw new Error(`${init?.method ?? "GET"} ${path25} returned invalid JSON`);
     }
   }
   async balance() {
@@ -1369,6 +1504,7 @@ import { z as z2 } from "zod";
 var MediaTypeSchema = z2.enum(["image/png", "image/gif"]);
 var GeneratorSchema = z2.enum(["1dir", "map", "pixflux", "tiles", "animation"]);
 var GridConfidenceSchema = z2.enum(["low", "medium", "high"]);
+var RevisionModeSchema = z2.enum(["image-to-image", "inpaint", "outpaint"]);
 function tileVariationCount(descriptions) {
   return Math.max(1, descriptions) * 4;
 }
@@ -1419,6 +1555,31 @@ var QualityProfileSchema = z2.object({
   (profile) => new Set(profile.palette.map((color) => color.replace(/^#/, "").toLowerCase())).size === profile.palette.length,
   { message: "quality palette colors must be unique", path: ["palette"] }
 );
+var RevisionSchema = z2.object({
+  /** What kind of controlled change the provider workflow performs. */
+  mode: RevisionModeSchema,
+  /** Parent asset id in the same style. */
+  from: z2.string().min(1),
+  /** Manifest-relative black/white PNG. Required only for masked inpainting. */
+  mask: z2.string().min(1).optional(),
+  /** Provider-neutral edit strength. The active adapter must bind it explicitly. */
+  strength: z2.number().min(0).max(1).optional()
+}).strict().superRefine((revision, context) => {
+  if (revision.mode === "inpaint" && !revision.mask) {
+    context.addIssue({
+      code: z2.ZodIssueCode.custom,
+      message: "inpaint revisions require a mask",
+      path: ["mask"]
+    });
+  }
+  if (revision.mode !== "inpaint" && revision.mask) {
+    context.addIssue({
+      code: z2.ZodIssueCode.custom,
+      message: `${revision.mode} revisions do not accept a mask`,
+      path: ["mask"]
+    });
+  }
+});
 var StyleSchema = z2.object({
   /** Generation backend for this style. Omit to inherit the manifest default. */
   provider: z2.string().min(1).optional(),
@@ -1584,6 +1745,8 @@ var AssetSchema = z2.object({
    * that wasn't. `prompt` still records what was asked for.
    */
   source: z2.string().optional(),
+  /** Controlled generation derived from another asset in the same style. */
+  revision: RevisionSchema.optional(),
   /**
    * Generated output role to place in `cell` when this asset expands to
    * several files. Omit for ordinary single-output assets. A structural set
@@ -1604,7 +1767,15 @@ var AssetSchema = z2.object({
    * style would invalidate every other style's already-generated art.
    */
   promptByStyle: z2.record(z2.string()).default({})
-}).strict();
+}).strict().superRefine((asset, context) => {
+  if (asset.source && asset.revision) {
+    context.addIssue({
+      code: z2.ZodIssueCode.custom,
+      message: "source and revision are mutually exclusive",
+      path: ["revision"]
+    });
+  }
+});
 var ManifestSchema = z2.object({
   $schema: z2.string().optional(),
   name: z2.string(),
@@ -1625,6 +1796,14 @@ var LockEntrySchema = z2.object({
   prompt: z2.string(),
   width: z2.number().int(),
   height: z2.number().int(),
+  /** Explicit parent/input lineage for a revision generation. */
+  revision: z2.object({
+    mode: RevisionModeSchema,
+    sourceAssetId: z2.string().min(1),
+    sourceSha256: z2.string().regex(/^[0-9a-f]{64}$/),
+    maskSha256: z2.string().regex(/^[0-9a-f]{64}$/).optional(),
+    strength: z2.number().min(0).max(1).optional()
+  }).strict().nullable().default(null),
   /** Set at submit time, before the request is awaited, so a crash is recoverable. */
   jobId: z2.string().nullable().default(null),
   /** For `1dir`: the multi-candidate parent object awaiting selection. */
@@ -2032,9 +2211,9 @@ var RetroDiffusionClient = class {
     }
     return balance;
   }
-  async call(path24, init = {}) {
+  async call(path25, init = {}) {
     if (!this.token) throw new Error("RD_API_KEY is not set");
-    const response = await this.request(`${this.baseUrl}${path24}`, {
+    const response = await this.request(`${this.baseUrl}${path25}`, {
       ...init,
       headers: {
         "Content-Type": "application/json",
@@ -2908,7 +3087,36 @@ ${issues}`);
         unknownReferences.push(`assets.${assetId}.promptByStyle: unknown style "${styleId}"`);
       }
     }
+    if (asset.revision) {
+      if (!parsed.data.assets[asset.revision.from]) {
+        unknownReferences.push(
+          `assets.${assetId}.revision.from: unknown asset "${asset.revision.from}"`
+        );
+      } else if (asset.revision.from === assetId) {
+        unknownReferences.push(`assets.${assetId}.revision.from: an asset cannot revise itself`);
+      }
+    }
   }
+  const visiting = /* @__PURE__ */ new Set();
+  const visited = /* @__PURE__ */ new Set();
+  const visitRevision = (assetId, chain) => {
+    if (visited.has(assetId)) return;
+    if (visiting.has(assetId)) {
+      const start = chain.indexOf(assetId);
+      unknownReferences.push(
+        `assets.${assetId}.revision.from: revision cycle ${[...chain.slice(start), assetId].join(" -> ")}`
+      );
+      return;
+    }
+    visiting.add(assetId);
+    const parent = parsed.data.assets[assetId]?.revision?.from;
+    if (parent && parent !== assetId && parsed.data.assets[parent]) {
+      visitRevision(parent, [...chain, assetId]);
+    }
+    visiting.delete(assetId);
+    visited.add(assetId);
+  };
+  for (const assetId of Object.keys(parsed.data.assets)) visitRevision(assetId, []);
   if (unknownReferences.length) {
     throw new Error(`Manifest at ${abs} is invalid:
 ${unknownReferences.map((i) => `  ${i}`).join("\n")}`);
@@ -2944,6 +3152,15 @@ async function resolveSpecs(loaded, filter) {
       throw new Error(`Unknown asset "${unknownAsset}".`);
     }
   }
+  const requestedAssetIds = new Set(filter?.assets?.length ? filter.assets : Object.keys(manifest.assets));
+  const resolutionAssetIds = new Set(requestedAssetIds);
+  for (const assetId of [...requestedAssetIds]) {
+    let current = manifest.assets[assetId]?.revision?.from;
+    while (current && !resolutionAssetIds.has(current)) {
+      resolutionAssetIds.add(current);
+      current = manifest.assets[current]?.revision?.from;
+    }
+  }
   const styleImageCache = /* @__PURE__ */ new Map();
   async function loadStyleImage(rel) {
     const abs = path4.resolve(root, rel);
@@ -2975,8 +3192,13 @@ async function resolveSpecs(loaded, filter) {
       styleImageHashes.push(loadedImage.hash);
       styleImageDimensions.push(loadedImage);
     }
+    const resolvedImages = style.styleImages.map((image) => {
+      const hit = styleImageCache.get(path4.resolve(root, image.path));
+      return { base64: hit.base64, width: hit.width, height: hit.height, format: hit.format };
+    });
+    const styleSpecs = /* @__PURE__ */ new Map();
     for (const [assetId, asset] of Object.entries(manifest.assets)) {
-      if (filter?.assets?.length && !filter.assets.includes(assetId)) continue;
+      if (!resolutionAssetIds.has(assetId)) continue;
       if (asset.styles.length && !asset.styles.includes(styleId)) continue;
       const generator = style.generator;
       if (!activeProvider.supports(generator)) {
@@ -3056,18 +3278,69 @@ async function resolveSpecs(loaded, filter) {
         } : {},
         tags,
         source: asset.source,
-        specHash: specHash(base, styleImageHashes, providerOptionIdentity)
+        // Revision identity is attached after every dependency in this style
+        // has a concrete output target. Finalization below computes the hash.
+        specHash: ""
       };
-      const resolvedImages = style.styleImages.map((image) => {
-        const hit = styleImageCache.get(path4.resolve(root, image.path));
-        return { base64: hit.base64, width: hit.width, height: hit.height, format: hit.format };
-      });
+      styleSpecs.set(assetId, resolved);
+    }
+    const finalized = /* @__PURE__ */ new Set();
+    const finalize = async (assetId) => {
+      const resolved = styleSpecs.get(assetId);
+      if (!resolved) {
+        throw new Error(
+          `Asset "${assetId}" is not available in style "${styleId}"; revision parents must participate in the same style.`
+        );
+      }
+      if (finalized.has(assetId)) return resolved;
+      const asset = manifest.assets[assetId];
+      if (asset.revision) {
+        if (!activeProvider.supportsRevision?.(asset.revision.mode)) {
+          throw new Error(
+            `Provider "${activeProvider.id}" does not support ${asset.revision.mode} revisions`
+          );
+        }
+        const sourceSpec = await finalize(asset.revision.from);
+        const sourceFile = sourceSpec.quality?.outFile ?? (sourceSpec.source ? path4.resolve(root, sourceSpec.source) : sourceSpec.outFile);
+        const sourceImage = await optionalRevisionImage(sourceFile, "revision source");
+        const maskFile = asset.revision.mask ? path4.resolve(root, asset.revision.mask) : void 0;
+        const maskImage = maskFile ? await optionalRevisionImage(maskFile, "revision mask", "png") : null;
+        if (sourceImage && maskImage && (sourceImage.width !== maskImage.width || sourceImage.height !== maskImage.height)) {
+          throw new Error(
+            `Revision mask for ${styleId}/${assetId} is ${maskImage.width}x${maskImage.height}; source ${asset.revision.from} is ${sourceImage.width}x${sourceImage.height}`
+          );
+        }
+        resolved.revision = {
+          mode: asset.revision.mode,
+          sourceAssetId: asset.revision.from,
+          sourceFile,
+          sourceSha256: sourceImage?.hash ?? null,
+          sourceWidth: sourceImage?.width ?? null,
+          sourceHeight: sourceImage?.height ?? null,
+          sourceFormat: sourceImage?.format ?? null,
+          sourceSpec,
+          ...maskFile ? {
+            maskFile,
+            maskSha256: maskImage?.hash ?? null,
+            maskWidth: maskImage?.width ?? null,
+            maskHeight: maskImage?.height ?? null,
+            maskFormat: maskImage?.format ?? null
+          } : {},
+          ...asset.revision.strength == null ? {} : { strength: asset.revision.strength }
+        };
+      }
+      resolved.specHash = specHash(resolved, styleImageHashes, providerOptionIdentity);
       activeProvider.validate?.(resolved, resolvedImages);
       const estimate = validateCostEstimate(activeProvider.id, activeProvider.estimate(resolved));
       resolved.cost = estimate.amount;
       resolved.costUnit = estimate.unit;
       resolved.candidates = estimate.candidates;
-      specs.push(resolved);
+      finalized.add(assetId);
+      return resolved;
+    };
+    for (const assetId of Object.keys(manifest.assets)) {
+      if (!requestedAssetIds.has(assetId) || !styleSpecs.has(assetId)) continue;
+      specs.push(await finalize(assetId));
     }
   }
   const byOutput = /* @__PURE__ */ new Map();
@@ -3089,6 +3362,16 @@ function pngPath(file) {
   const extension = path4.extname(file);
   return extension ? `${file.slice(0, -extension.length)}.png` : `${file}.png`;
 }
+async function optionalRevisionImage(file, label, requiredFormat) {
+  if (!existsSync3(file)) return null;
+  const bytes = await readFile2(file);
+  const metadata = imageMetadata(bytes);
+  if (!metadata) throw new Error(`${label} is not a readable PNG or JPEG: ${file}`);
+  if (requiredFormat && metadata.format !== requiredFormat) {
+    throw new Error(`${label} must be ${requiredFormat.toUpperCase()}: ${file}`);
+  }
+  return { hash: sha256(bytes), ...metadata };
+}
 async function resolveStyleImages(loaded, styleId) {
   const style = loaded.manifest.styles[styleId];
   if (!style) throw new Error(`Unknown style "${styleId}"`);
@@ -3677,8 +3960,8 @@ function mountStyle(lock, styleId, manifestDir, mount, cells, sources = {}, outp
 }
 
 // src/pipeline/plan.ts
-import { existsSync as existsSync7 } from "fs";
-import path12 from "path";
+import { existsSync as existsSync8 } from "fs";
+import path13 from "path";
 
 // src/pipeline/quality-profile.ts
 import { existsSync as existsSync6 } from "fs";
@@ -4831,6 +5114,83 @@ async function requireApprovedQualitySources(specs, lock, assetIds) {
   return sources;
 }
 
+// src/pipeline/revision.ts
+import { existsSync as existsSync7 } from "fs";
+import path12 from "path";
+async function inspectRevisionReadiness(spec, lock) {
+  if (!spec.revision) return null;
+  return inspectRevision(spec, lock, /* @__PURE__ */ new Set());
+}
+async function inspectRevision(spec, lock, seen) {
+  const revision = spec.revision;
+  if (!revision) return { ready: true, reason: "asset has no revision inputs" };
+  const dependency = await inspectParent(revision.sourceSpec, lock, seen);
+  if (!dependency.ready) {
+    return {
+      ready: false,
+      reason: `revision source ${spec.styleId}/${revision.sourceAssetId} is not ready: ${dependency.reason}`
+    };
+  }
+  if (!revision.sourceSha256 || !existsSync7(revision.sourceFile)) {
+    return { ready: false, reason: `revision source is missing: ${revision.sourceFile}` };
+  }
+  if (await sha256File(revision.sourceFile) !== revision.sourceSha256) {
+    return { ready: false, reason: "revision source changed after the manifest was resolved" };
+  }
+  if (revision.maskFile) {
+    if (!revision.maskSha256 || !existsSync7(revision.maskFile)) {
+      return { ready: false, reason: `revision mask is missing: ${revision.maskFile}` };
+    }
+    if (await sha256File(revision.maskFile) !== revision.maskSha256) {
+      return { ready: false, reason: "revision mask changed after the manifest was resolved" };
+    }
+  }
+  return { ready: true, reason: "revision inputs are current" };
+}
+async function requireRevisionReady(spec, lock) {
+  const inspection = await inspectRevisionReadiness(spec, lock);
+  if (inspection && !inspection.ready) throw new Error(inspection.reason);
+}
+async function inspectParent(spec, lock, seen) {
+  const key = lockKey(spec.styleId, spec.assetId);
+  if (seen.has(key)) return { ready: false, reason: `revision dependency cycle at ${key}` };
+  const nextSeen = new Set(seen);
+  nextSeen.add(key);
+  if (spec.revision) {
+    const inputs = await inspectRevision(spec, lock, nextSeen);
+    if (!inputs.ready) return inputs;
+  }
+  if (spec.quality) {
+    const quality = await inspectQualityProfile(spec, lock);
+    return quality?.state === "approved" ? { ready: true, reason: "approved quality output is current" } : {
+      ready: false,
+      reason: `quality output is ${quality?.state ?? "missing"}` + (quality?.reason ? ` (${quality.reason})` : "")
+    };
+  }
+  if (spec.source) {
+    const source = path12.resolve(spec.root, spec.source);
+    return existsSync7(source) ? { ready: true, reason: "declared source is present" } : { ready: false, reason: `declared source is missing: ${spec.source}` };
+  }
+  const entry = lock.entries[key];
+  if (!entry) return { ready: false, reason: "parent is not in the lockfile" };
+  if (entry.specHash !== spec.specHash) {
+    return { ready: false, reason: "parent generation spec is stale" };
+  }
+  if (entry.status !== "downloaded") {
+    return { ready: false, reason: `parent is ${entry.status}, not downloaded` };
+  }
+  if (!entry.outputs.length) return { ready: false, reason: "parent has no recorded output" };
+  for (let index = 0; index < entry.outputs.length; index++) {
+    const output = entry.outputs[index];
+    const file = currentEntryOutputPath(entry, spec, index);
+    if (!existsSync7(file)) return { ready: false, reason: `parent output is missing: ${file}` };
+    if (await sha256File(file) !== output.sha256) {
+      return { ready: false, reason: `parent output was modified: ${file}` };
+    }
+  }
+  return { ready: true, reason: "parent output is current" };
+}
+
 // src/pipeline/plan.ts
 async function anyOutputModified(entry, spec) {
   for (let index = 0; index < entry.outputs.length; index++) {
@@ -4846,11 +5206,15 @@ async function buildPlan(specs, lock, opts = {}) {
     const entry = lock.entries[key];
     let state;
     let reason;
-    if (opts.force) {
+    const revision = await inspectRevisionReadiness(spec, lock);
+    if (revision && !revision.ready) {
+      state = "blocked";
+      reason = revision.reason;
+    } else if (opts.force) {
       state = "missing";
       reason = "--force";
     } else if (!entry && spec.source) {
-      if (existsSync7(path12.resolve(spec.root, spec.source))) {
+      if (existsSync8(path13.resolve(spec.root, spec.source))) {
         state = "ok";
         reason = `placed from ${spec.source}; not generated`;
       } else {
@@ -4858,7 +5222,7 @@ async function buildPlan(specs, lock, opts = {}) {
         reason = `declared source is missing: ${spec.source}`;
       }
     } else if (!entry) {
-      if (existsSync7(spec.outFile)) {
+      if (existsSync8(spec.outFile)) {
         state = "untracked";
         reason = "file on disk, no provenance recorded";
       } else {
@@ -4877,9 +5241,9 @@ async function buildPlan(specs, lock, opts = {}) {
     } else if (entry.status !== "downloaded") {
       state = "in-flight";
       reason = `awaiting ${entry.status}`;
-    } else if (entry.outputs.length === 0 || entry.outputs.some((_output, index) => !existsSync7(currentEntryOutputPath(entry, spec, index)))) {
+    } else if (entry.outputs.length === 0 || entry.outputs.some((_output, index) => !existsSync8(currentEntryOutputPath(entry, spec, index)))) {
       state = "orphaned";
-      reason = entry.outputs.length === 0 ? "no recorded output files" : `missing on disk: ${entry.outputs.filter((_output, index) => !existsSync7(currentEntryOutputPath(entry, spec, index))).map((o) => o.role ?? "asset").join(", ")}`;
+      reason = entry.outputs.length === 0 ? "no recorded output files" : `missing on disk: ${entry.outputs.filter((_output, index) => !existsSync8(currentEntryOutputPath(entry, spec, index))).map((o) => o.role ?? "asset").join(", ")}`;
     } else if (await anyOutputModified(entry, spec)) {
       state = "orphaned";
       reason = "output modified since download";
@@ -4936,6 +5300,7 @@ function summarize(plan) {
     orphaned: 0,
     "in-flight": 0,
     recoverable: 0,
+    blocked: 0,
     failed: 0
   };
   for (const item of plan.items) counts[item.state]++;
@@ -5008,6 +5373,7 @@ async function submit(provider, loaded, items, lock, lockPath, opts = {}) {
     await waitForSlot();
     const since = Date.now() - lastSubmitAt;
     if (since < spacing) await sleep2(spacing - since);
+    await requireRevisionReady(spec, lock);
     upsert(lock, key, {
       styleId: spec.styleId,
       assetId: spec.assetId,
@@ -5017,6 +5383,13 @@ async function submit(provider, loaded, items, lock, lockPath, opts = {}) {
       prompt: spec.prompt,
       width: spec.width,
       height: spec.height,
+      revision: spec.revision ? {
+        mode: spec.revision.mode,
+        sourceAssetId: spec.revision.sourceAssetId,
+        sourceSha256: spec.revision.sourceSha256,
+        ...spec.revision.maskSha256 ? { maskSha256: spec.revision.maskSha256 } : {},
+        ...spec.revision.strength == null ? {} : { strength: spec.revision.strength }
+      } : null,
       status: "pending",
       jobId: null,
       objectId: null,
@@ -5142,9 +5515,9 @@ async function poll(provider, lock, lockPath, opts = {}) {
 }
 
 // src/pipeline/fetch.ts
-import { existsSync as existsSync8 } from "fs";
+import { existsSync as existsSync9 } from "fs";
 import { mkdir as mkdir3, readFile as readFile7, rename as rename3, rm as rm4, writeFile as writeFile3 } from "fs/promises";
-import path13 from "path";
+import path14 from "path";
 
 // src/source-url.ts
 var SENSITIVE_QUERY_KEYS = /* @__PURE__ */ new Set([
@@ -5190,13 +5563,13 @@ async function fetchAssets(provider, specs, lock, lockPath, opts = {}) {
   const result = { downloaded: 0, skipped: 0, failed: 0 };
   const specByKey = new Map(specs.map((s) => [lockKey(s.styleId, s.assetId), s]));
   normalizeLockOutputPaths(lock, specs);
-  const cacheDir = opts.cacheDir === false ? null : path13.resolve(opts.cacheDir ?? path13.join(path13.dirname(lockPath), ".pixelkiln", "cache"));
+  const cacheDir = opts.cacheDir === false ? null : path14.resolve(opts.cacheDir ?? path14.join(path14.dirname(lockPath), ".pixelkiln", "cache"));
   const pending = Object.entries(lock.entries).filter(([key, e]) => {
     if (e.provider !== provider.id || !specByKey.has(key)) return false;
     if (e.status === "selected" || e.status === "download-failed") return true;
     if (!opts.repair || e.status !== "downloaded") return false;
     const spec = specByKey.get(key);
-    return e.outputs.length === 0 || !spec || e.outputs.some((output) => !existsSync8(resolveOutputPath(output.path, spec.root)));
+    return e.outputs.length === 0 || !spec || e.outputs.some((output) => !existsSync9(resolveOutputPath(output.path, spec.root)));
   });
   const concurrency = Math.min(Math.max(1, opts.concurrency ?? 8), Math.max(1, pending.length));
   let cursor = 0;
@@ -5233,7 +5606,7 @@ async function fetchAssets(provider, specs, lock, lockPath, opts = {}) {
             (o) => source.role ? o.role === source.role : !o.role && sources.length === 1
           );
           const target = recorded ? resolveOutputPath(recorded.path, spec.root) : expectedOutputPath(spec, source.role, index, sources.length, source.mediaType);
-          if (existsSync8(target)) {
+          if (existsSync9(target)) {
             if (!recorded) {
               throw new Error(`refusing to overwrite untracked output ${target}`);
             }
@@ -5254,7 +5627,7 @@ async function fetchAssets(provider, specs, lock, lockPath, opts = {}) {
           const expectedMediaType = source.mediaType ?? recorded?.mediaType ?? MediaType.PNG;
           let buf = recorded && cacheDir ? await readCachedMedia(cacheDir, recorded.sha256, expectedMediaType) : null;
           if (buf) {
-            log2(`  cached  ${path13.relative(process.cwd(), target)}`);
+            log2(`  cached  ${path14.relative(process.cwd(), target)}`);
           } else {
             if (!source.url) {
               throw new Error(`no source URL or cached bytes remain for ${source.role ?? "asset"}`);
@@ -5272,7 +5645,7 @@ async function fetchAssets(provider, specs, lock, lockPath, opts = {}) {
             );
           }
           if (cacheDir) await cacheMedia(cacheDir, buf, mediaType);
-          await mkdir3(path13.dirname(target), { recursive: true });
+          await mkdir3(path14.dirname(target), { recursive: true });
           const tmp = `${target}.pixelkiln.tmp`;
           await writeFile3(tmp, buf);
           outputs.push({
@@ -5284,7 +5657,7 @@ async function fetchAssets(provider, specs, lock, lockPath, opts = {}) {
           upsert(lock, key, { outputs: mergeOutputs(entry.outputs, outputs) });
           await saveLock(lockPath, lock);
           await rename3(tmp, target);
-          log2(`  wrote   ${path13.relative(process.cwd(), target)}`);
+          log2(`  wrote   ${path14.relative(process.cwd(), target)}`);
         }
         const persistentSources = sources.filter((source) => shouldPersistSourceUrl(source.url));
         upsert(lock, key, {
@@ -5318,8 +5691,8 @@ async function fetchAssets(provider, specs, lock, lockPath, opts = {}) {
   return result;
 }
 async function readCachedMedia(cacheDir, hash, mediaType) {
-  const file = path13.join(cacheDir, cacheFileName(hash, mediaType));
-  if (!existsSync8(file)) return null;
+  const file = path14.join(cacheDir, cacheFileName(hash, mediaType));
+  if (!existsSync9(file)) return null;
   try {
     const buf = await readFile7(file);
     if (sha256(buf) !== hash) return null;
@@ -5332,7 +5705,7 @@ async function readCachedMedia(cacheDir, hash, mediaType) {
 async function cacheMedia(cacheDir, buf, mediaType, knownHash) {
   const hash = knownHash ?? sha256(buf);
   validateMedia(buf, mediaType);
-  const file = path13.join(cacheDir, cacheFileName(hash, mediaType));
+  const file = path14.join(cacheDir, cacheFileName(hash, mediaType));
   if (await readCachedMedia(cacheDir, hash, mediaType)) return;
   await mkdir3(cacheDir, { recursive: true });
   const tmp = `${file}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
@@ -5340,7 +5713,7 @@ async function cacheMedia(cacheDir, buf, mediaType, knownHash) {
   try {
     await rename3(tmp, file);
   } catch (err) {
-    if (!existsSync8(file)) throw err;
+    if (!existsSync9(file)) throw err;
   } finally {
     await rm4(tmp, { force: true });
   }
@@ -5373,9 +5746,9 @@ async function pushTags(provider, specs, lock, opts = {}) {
 }
 
 // src/pipeline/doctor.ts
-import { constants, existsSync as existsSync9 } from "fs";
+import { constants, existsSync as existsSync10 } from "fs";
 import { access, stat as stat2 } from "fs/promises";
-import path14 from "path";
+import path15 from "path";
 async function doctor(loaded, specs, lock, lockPath, opts = {}) {
   const checks = [];
   const add = (id, level, message5) => checks.push({ id, level, message: message5 });
@@ -5386,8 +5759,8 @@ async function doctor(loaded, specs, lock, lockPath, opts = {}) {
   );
   add("lock", "ok", `${Object.keys(lock.entries).length} valid v2 lock entr(ies)`);
   const dirs = [...new Set(specs.flatMap((spec) => [
-    path14.dirname(spec.outFile),
-    ...spec.quality ? [path14.dirname(spec.quality.outFile)] : []
+    path15.dirname(spec.outFile),
+    ...spec.quality ? [path15.dirname(spec.quality.outFile)] : []
   ]))];
   const unwritable = [];
   for (const dir of dirs) {
@@ -5410,7 +5783,7 @@ async function doctor(loaded, specs, lock, lockPath, opts = {}) {
     for (let index = 0; index < entry.outputs.length; index++) {
       const output = entry.outputs[index];
       const spec = specByKey.get(key);
-      const absolute = spec ? currentEntryOutputPath(entry, spec, index) : resolveOutputPath(output.path, path14.dirname(lockPath));
+      const absolute = spec ? currentEntryOutputPath(entry, spec, index) : resolveOutputPath(output.path, path15.dirname(lockPath));
       const owner = outputOwners.get(absolute);
       if (owner && owner !== key) duplicateOutputs.push(`${output.path} (${owner}, ${key})`);
       outputOwners.set(absolute, key);
@@ -5425,7 +5798,7 @@ async function doctor(loaded, specs, lock, lockPath, opts = {}) {
   } else {
     add("lock-outputs", "ok", `${outputOwners.size} recorded output path(s) are uniquely owned`);
   }
-  const cacheDir = path14.join(path14.dirname(lockPath), ".pixelkiln", "cache");
+  const cacheDir = path15.join(path15.dirname(lockPath), ".pixelkiln", "cache");
   const stranded = [];
   const invalidState = [];
   const staleMapUrls = [];
@@ -5441,11 +5814,11 @@ async function doctor(loaded, specs, lock, lockPath, opts = {}) {
     const hasSource = Boolean(entry.sourceUrl || entry.sourceUrls?.length);
     let hasCache = false;
     for (const output of entry.outputs) {
-      const cached = path14.join(
+      const cached = path15.join(
         cacheDir,
         cacheFileName(output.sha256, output.mediaType ?? MediaType.PNG)
       );
-      if (existsSync9(cached) && await sha256File(cached) === output.sha256) {
+      if (existsSync10(cached) && await sha256File(cached) === output.sha256) {
         hasCache = true;
         break;
       }
@@ -5533,20 +5906,20 @@ async function nearestExistingDirectory(start) {
       if ((await stat2(current)).isDirectory()) return current;
     } catch {
     }
-    const parent = path14.dirname(current);
+    const parent = path15.dirname(current);
     if (parent === current) return current;
     current = parent;
   }
 }
 
 // src/pipeline/adopt.ts
-import { existsSync as existsSync11 } from "fs";
+import { existsSync as existsSync12 } from "fs";
 import { readFile as readFile9, writeFile as writeFile5 } from "fs/promises";
-import path15 from "path";
+import path16 from "path";
 
 // src/cache.ts
 import { mkdir as mkdir4, readFile as readFile8, rename as rename4, rm as rm5, writeFile as writeFile4 } from "fs/promises";
-import { existsSync as existsSync10 } from "fs";
+import { existsSync as existsSync11 } from "fs";
 import pathModule from "path";
 import { z as z3 } from "zod";
 var HashCacheSchema = z3.object({
@@ -5561,10 +5934,10 @@ function isSha256Hash(value) {
 function parseCache(value) {
   return HashCacheSchema.parse(value);
 }
-async function loadCache(path24) {
-  if (!existsSync10(path24)) return { version: 1, hashes: {} };
+async function loadCache(path25) {
+  if (!existsSync11(path25)) return { version: 1, hashes: {} };
   try {
-    const parsed = HashCacheSchema.safeParse(JSON.parse(await readFile8(path24, "utf8")));
+    const parsed = HashCacheSchema.safeParse(JSON.parse(await readFile8(path25, "utf8")));
     if (!parsed.success) return { version: 1, hashes: {} };
     return {
       version: 1,
@@ -5576,18 +5949,18 @@ async function loadCache(path24) {
     return { version: 1, hashes: {} };
   }
 }
-async function saveCache(path24, cache) {
+async function saveCache(path25, cache) {
   const sorted = {};
   for (const key of Object.keys(cache.hashes).sort()) {
     const hash = cache.hashes[key];
     if (!isSha256Hash(hash)) throw new Error(`Refusing to cache invalid SHA-256 for ${key}`);
     sorted[key] = hash;
   }
-  await mkdir4(pathModule.dirname(pathModule.resolve(path24)), { recursive: true });
-  const tmp = `${path24}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
+  await mkdir4(pathModule.dirname(pathModule.resolve(path25)), { recursive: true });
+  const tmp = `${path25}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
   try {
     await writeFile4(tmp, JSON.stringify({ version: 1, hashes: sorted }, null, 2) + "\n");
-    await rename4(tmp, path24);
+    await rename4(tmp, path25);
   } finally {
     await rm5(tmp, { force: true });
   }
@@ -5618,7 +5991,7 @@ async function adopt(provider, specs, lock, lockPath, opts = {}) {
   const localByHash = /* @__PURE__ */ new Map();
   const unmatchedLocal = [];
   for (const spec of specs) {
-    if (!existsSync11(spec.outFile)) {
+    if (!existsSync12(spec.outFile)) {
       unmatchedLocal.push(`${spec.styleId}/${spec.assetId} (no file at ${spec.outFile})`);
       continue;
     }
@@ -5781,7 +6154,13 @@ function renderSheet(groups) {
     ...g,
     styleId: escapeHtml(g.styleId),
     assetId: escapeHtml(g.assetId),
-    prompt: escapeHtml(g.prompt)
+    prompt: escapeHtml(g.prompt),
+    ...g.revision ? {
+      revision: {
+        ...g.revision,
+        sourceAssetId: escapeHtml(g.revision.sourceAssetId)
+      }
+    } : {}
   }));
   const data = JSON.stringify(safe).replace(/<\//g, "<\\/");
   return `<!doctype html>
@@ -5822,6 +6201,18 @@ function renderSheet(groups) {
     color:var(--accent-soft); border:1px solid var(--accent); border-radius:0; padding:2px 6px; }
   .aid { font-weight:650; font-family:ui-monospace,SFMono-Regular,Menlo,monospace; }
   .prompt { flex:1; min-width:280px; color:var(--dim); font-size:12.5px; max-width:80ch; }
+  .review { display:grid; grid-template-columns:minmax(180px,280px) minmax(0,1fr); gap:16px;
+    align-items:start; }
+  .review.no-context { display:block; }
+  .context { border:1px solid var(--line); padding:8px; background:var(--panel-deep);
+    min-width:0; }
+  .context-label { display:flex; justify-content:space-between; gap:8px; margin-bottom:7px;
+    color:var(--dim); font-size:10.5px; font-variant-numeric:tabular-nums; }
+  .context img { display:block; width:100%; height:auto; max-height:420px; object-fit:contain;
+    image-rendering:pixelated;
+    background-image:linear-gradient(45deg,#0000 25%,#7f7f7f22 25%,#7f7f7f22 75%,#0000 75%),
+      linear-gradient(45deg,#0000 25%,#7f7f7f22 25%,#7f7f7f22 75%,#0000 75%);
+    background-size:12px 12px; background-position:0 0,6px 6px; }
   .frames { display:flex; flex-wrap:wrap; gap:10px; max-width:100%; overflow-x:auto; }
   .cand { border:2px solid var(--line-strong); border-radius:0; padding:7px; background:var(--panel-deep);
     cursor:pointer; display:flex; flex:0 0 auto; flex-direction:column; align-items:center; gap:5px;
@@ -5848,6 +6239,10 @@ function renderSheet(groups) {
     .prompt { min-width:100%; }
     .cand img.preview { max-width:calc(100vw - 50px); }
   }
+  @media (max-width:900px) {
+    .review { grid-template-columns:1fr; }
+    .context { max-width:280px; }
+  }
 </style>
 </head>
 <body>
@@ -5890,8 +6285,26 @@ GROUPS.forEach((g, gi) => {
     '<div class="ghead"><span class="style">' + g.styleId + '</span>' +
     '<span class="aid">' + g.assetId + '</span>' +
     '<span class="prompt">' + g.prompt + '</span></div>' +
-    '<div class="frames"></div>';
+    '<div class="review' + (g.revision ? '' : ' no-context') + '">' +
+    '<div class="frames"></div></div>';
+  const review = el.querySelector('.review');
   const frames = el.querySelector('.frames');
+  if (g.revision) {
+    const context = document.createElement('aside');
+    context.className = 'context';
+    const label = document.createElement('div');
+    label.className = 'context-label';
+    const identity = document.createElement('span');
+    identity.textContent = g.revision.mode.toUpperCase() + ' \xB7 SOURCE ' + g.revision.sourceAssetId;
+    const dimensions = document.createElement('span');
+    dimensions.textContent = g.revision.width + '\xD7' + g.revision.height;
+    label.append(identity, dimensions);
+    const source = document.createElement('img');
+    source.src = g.revision.sourceUrl;
+    source.alt = 'Revision source ' + g.revision.sourceAssetId;
+    context.append(label, source);
+    review.insertBefore(context, frames);
+  }
   g.frameUrls.forEach((url, i) => {
     const c = document.createElement('button');
     c.type = 'button';
@@ -6028,11 +6441,28 @@ document.getElementById('submit').onclick = async () => {
 // src/pick/review-server.ts
 import { createServer } from "http";
 import { spawn } from "child_process";
+import { readFile as readFile10 } from "fs/promises";
 function serveReviewPage(opts) {
   const log2 = opts.onProgress ?? (() => {
   });
   return new Promise((resolve, reject) => {
     const server = createServer(async (req, res) => {
+      if (req.method === "GET" && req.url && opts.assets?.has(req.url)) {
+        try {
+          const asset = opts.assets.get(req.url);
+          const bytes = await readFile10(asset.path);
+          res.writeHead(200, {
+            "Content-Type": asset.contentType,
+            "Cache-Control": "no-store",
+            "X-Content-Type-Options": "nosniff"
+          });
+          res.end(bytes);
+        } catch {
+          res.writeHead(404, { "Content-Type": "text/plain" });
+          res.end("review asset is unavailable");
+        }
+        return;
+      }
       if (req.method === "GET" && (req.url === "/" || req.url?.startsWith("/?"))) {
         res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
         res.end(opts.html);
@@ -6096,13 +6526,25 @@ async function runPicker(provider, lock, lockPath, opts = {}) {
   const log2 = opts.onProgress ?? (() => {
   });
   const selectedKeys = opts.keys ? new Set(opts.keys) : null;
+  const specByKey = new Map(
+    (opts.specs ?? []).map((spec) => [lockKey(spec.styleId, spec.assetId), spec])
+  );
+  const reviewAssets = /* @__PURE__ */ new Map();
   const groups = [];
   for (const [key, entry] of Object.entries(lock.entries)) {
     if (entry.provider !== provider.id || selectedKeys && !selectedKeys.has(key)) continue;
     if (entry.status !== "review" || !entry.reviewObjectId) continue;
     try {
-      const state = await provider.poll(entry.reviewObjectId, entry.generator);
+      const spec = specByKey.get(key);
+      const state = await provider.poll(entry.reviewObjectId, entry.generator, { spec });
       if (state.status !== "review" || !state.candidateUrls.length) continue;
+      const sourceRoute = spec?.revision ? `/revision-source/${encodeURIComponent(String(groups.length))}` : null;
+      if (sourceRoute && spec?.revision) {
+        reviewAssets.set(sourceRoute, {
+          path: spec.revision.sourceFile,
+          contentType: spec.revision.sourceFormat === "jpeg" ? "image/jpeg" : "image/png"
+        });
+      }
       groups.push({
         key,
         assetId: entry.assetId,
@@ -6111,7 +6553,16 @@ async function runPicker(provider, lock, lockPath, opts = {}) {
         reviewObjectId: entry.reviewObjectId,
         frameUrls: state.candidateUrls,
         width: entry.width,
-        height: entry.height
+        height: entry.height,
+        ...sourceRoute && spec?.revision && spec.revision.sourceWidth && spec.revision.sourceHeight ? {
+          revision: {
+            mode: spec.revision.mode,
+            sourceAssetId: spec.revision.sourceAssetId,
+            sourceUrl: sourceRoute,
+            width: spec.revision.sourceWidth,
+            height: spec.revision.sourceHeight
+          }
+        } : {}
       });
     } catch (err) {
       log2(`  could not load candidates for ${key}: ${err instanceof Error ? err.message : String(err)}`);
@@ -6125,6 +6576,7 @@ async function runPicker(provider, lock, lockPath, opts = {}) {
     port: opts.port,
     open: opts.open,
     onProgress: log2,
+    assets: reviewAssets,
     onReady: (url) => {
       log2(`
   ${groups.length} asset(s) awaiting selection: ${url}`);
@@ -6170,9 +6622,9 @@ async function runPicker(provider, lock, lockPath, opts = {}) {
 }
 
 // src/pipeline/init.ts
-import { readdir, readFile as readFile10, writeFile as writeFile6 } from "fs/promises";
-import { existsSync as existsSync12 } from "fs";
-import path16 from "path";
+import { readdir, readFile as readFile11, writeFile as writeFile6 } from "fs/promises";
+import { existsSync as existsSync13 } from "fs";
+import path17 from "path";
 function pngSize(buf) {
   if (buf.length < 24) return null;
   const isPng = buf.readUInt32BE(0) === 2303741511 && buf.readUInt32BE(4) === 218765834;
@@ -6186,7 +6638,7 @@ function slugify(value) {
 async function walk(dir, exclude) {
   const out = [];
   for (const entry of await readdir(dir, { withFileTypes: true })) {
-    const full = path16.join(dir, entry.name);
+    const full = path17.join(dir, entry.name);
     if (exclude.some((x) => full.includes(x))) continue;
     if (entry.isDirectory()) out.push(...await walk(full, exclude));
     else if (entry.name.toLowerCase().endsWith(".png")) out.push(full);
@@ -6200,14 +6652,14 @@ async function scanAssets(root, opts = {}) {
   const skipped = [];
   const seen = /* @__PURE__ */ new Map();
   for (const file of files.sort()) {
-    const size = pngSize(await readFile10(file));
+    const size = pngSize(await readFile11(file));
     if (!size) {
       skipped.push(`${file} (not a readable PNG)`);
       continue;
     }
-    const rel = path16.relative(root, file);
-    const category = path16.dirname(rel) === "." ? "" : path16.dirname(rel);
-    let id = slugify(path16.basename(rel));
+    const rel = path17.relative(root, file);
+    const category = path17.dirname(rel) === "." ? "" : path17.dirname(rel);
+    let id = slugify(path17.basename(rel));
     if (seen.has(id)) {
       const n = seen.get(id) + 1;
       seen.set(id, n);
@@ -6262,26 +6714,26 @@ function mode(values) {
   return [...counts.entries()].sort((a, b) => b[1] - a[1])[0]?.[0] ?? 64;
 }
 async function writeManifestFile(target, manifest) {
-  if (existsSync12(target)) {
+  if (existsSync13(target)) {
     throw new Error(`${target} already exists \u2014 refusing to overwrite an existing manifest.`);
   }
   await writeFile6(target, JSON.stringify(manifest, null, 2) + "\n");
 }
 
 // src/pipeline/salvage.ts
-import { readFile as readFile11 } from "fs/promises";
-import { existsSync as existsSync13 } from "fs";
-import path17 from "path";
+import { readFile as readFile12 } from "fs/promises";
+import { existsSync as existsSync14 } from "fs";
+import path18 from "path";
 function providerClaimId(provider, objectId) {
   return `${encodeURIComponent(provider)}:${encodeURIComponent(objectId)}`;
 }
 async function loadClaims(lockPaths, opts = {}) {
   const claimed = /* @__PURE__ */ new Set();
   for (const p of lockPaths) {
-    if (!existsSync13(p)) throw new Error(`Claim lockfile not found: ${p}`);
+    if (!existsSync14(p)) throw new Error(`Claim lockfile not found: ${p}`);
     let parsed;
     try {
-      parsed = parseLock(JSON.parse(await readFile11(p, "utf8")));
+      parsed = parseLock(JSON.parse(await readFile12(p, "utf8")));
     } catch {
       throw new Error(`Claim lockfile is malformed: ${p}`);
     }
@@ -6329,20 +6781,20 @@ function matchStyleByPattern(prompt, manifest) {
   return null;
 }
 async function loadSiblingManifests(ownManifestPath, workspaceManifestPaths, claimPaths) {
-  const own = path17.resolve(ownManifestPath);
+  const own = path18.resolve(ownManifestPath);
   const siblingManifestPaths = [
     .../* @__PURE__ */ new Set([
       ...workspaceManifestPaths,
-      ...claimPaths.map((c) => path17.join(path17.dirname(path17.resolve(c)), "pixelkiln.manifest.json"))
+      ...claimPaths.map((c) => path18.join(path18.dirname(path18.resolve(c)), "pixelkiln.manifest.json"))
     ])
   ];
   const siblings = [];
   for (const siblingManifestPath of siblingManifestPaths) {
-    if (path17.resolve(siblingManifestPath) === own) continue;
-    if (!existsSync13(siblingManifestPath)) continue;
+    if (path18.resolve(siblingManifestPath) === own) continue;
+    if (!existsSync14(siblingManifestPath)) continue;
     try {
       const { manifest } = await loadManifest(siblingManifestPath);
-      siblings.push({ label: path17.basename(path17.dirname(siblingManifestPath)), manifest });
+      siblings.push({ label: path18.basename(path18.dirname(siblingManifestPath)), manifest });
     } catch {
     }
   }
@@ -6458,9 +6910,9 @@ async function applyTags(provider, decisions, existing, opts = {}) {
 }
 
 // src/workspace.ts
-import { mkdir as mkdir5, readFile as readFile12, rename as rename5, rm as rm6, writeFile as writeFile7 } from "fs/promises";
-import { existsSync as existsSync14 } from "fs";
-import path18 from "path";
+import { mkdir as mkdir5, readFile as readFile13, rename as rename5, rm as rm6, writeFile as writeFile7 } from "fs/promises";
+import { existsSync as existsSync15 } from "fs";
+import path19 from "path";
 import { z as z4 } from "zod";
 var WorkspaceProjectSchema = z4.object({
   id: z4.string().min(1),
@@ -6485,10 +6937,10 @@ ${parsed.error.issues.slice(0, 5).map((i) => `  ${i.path.join(".")}: ${i.message
   );
 }
 async function loadWorkspace(workspacePath) {
-  if (!existsSync14(workspacePath)) return { version: 1, projects: [] };
+  if (!existsSync15(workspacePath)) return { version: 1, projects: [] };
   let raw;
   try {
-    raw = JSON.parse(await readFile12(workspacePath, "utf8"));
+    raw = JSON.parse(await readFile13(workspacePath, "utf8"));
   } catch (err) {
     throw new Error(
       `Workspace catalog at ${workspacePath} is malformed:
@@ -6502,7 +6954,7 @@ async function saveWorkspace(workspacePath, ws) {
     version: 1,
     projects: [...ws.projects].sort((a, b) => a.id.localeCompare(b.id))
   };
-  await mkdir5(path18.dirname(path18.resolve(workspacePath)), { recursive: true });
+  await mkdir5(path19.dirname(path19.resolve(workspacePath)), { recursive: true });
   const tmp = `${workspacePath}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
   try {
     await writeFile7(tmp, JSON.stringify(sorted, null, 2) + "\n");
@@ -6512,12 +6964,12 @@ async function saveWorkspace(workspacePath, ws) {
   }
 }
 function toPortablePath(dir, absolute) {
-  return path18.relative(dir, absolute).split(path18.sep).join("/");
+  return path19.relative(dir, absolute).split(path19.sep).join("/");
 }
 function resolveProject(dir, project) {
   return {
-    manifestPath: path18.resolve(dir, project.manifest.split("/").join(path18.sep)),
-    lockPath: path18.resolve(dir, project.lock.split("/").join(path18.sep))
+    manifestPath: path19.resolve(dir, project.manifest.split("/").join(path19.sep)),
+    lockPath: path19.resolve(dir, project.lock.split("/").join(path19.sep))
   };
 }
 function validateWorkspace(ws, dir) {
@@ -6530,21 +6982,21 @@ function validateWorkspace(ws, dir) {
     const { manifestPath, lockPath } = resolveProject(dir, project);
     lockOwners.set(lockPath, [...lockOwners.get(lockPath) ?? [], project.id]);
     manifestOwners.set(manifestPath, [...manifestOwners.get(manifestPath) ?? [], project.id]);
-    if (path18.isAbsolute(project.manifest) || path18.isAbsolute(project.lock)) {
+    if (path19.isAbsolute(project.manifest) || path19.isAbsolute(project.lock)) {
       diagnostics.push({
         id: "absolute-path",
         level: "warning",
         message: `project "${project.id}" stores an absolute path \u2014 the catalog will not resolve correctly if this tree is cloned or moved elsewhere`
       });
     }
-    if (!existsSync14(manifestPath)) {
+    if (!existsSync15(manifestPath)) {
       diagnostics.push({
         id: "missing-manifest",
         level: "error",
         message: `project "${project.id}" manifest not found: ${manifestPath}`
       });
     }
-    if (!existsSync14(lockPath)) {
+    if (!existsSync15(lockPath)) {
       diagnostics.push({
         id: "missing-lock",
         level: "error",
@@ -6620,6 +7072,7 @@ function emptyStateCounts() {
     orphaned: 0,
     "in-flight": 0,
     recoverable: 0,
+    blocked: 0,
     failed: 0
   };
 }
@@ -6693,15 +7146,15 @@ async function workspaceStatus(ws, dir) {
 }
 
 // src/pipeline/cache-health.ts
-import { existsSync as existsSync15 } from "fs";
-import { readFile as readFile13, readdir as readdir2, rm as rm7 } from "fs/promises";
-import path19 from "path";
+import { existsSync as existsSync16 } from "fs";
+import { readFile as readFile14, readdir as readdir2, rm as rm7 } from "fs/promises";
+import path20 from "path";
 async function inspectCaches(lock, lockPath, options = {}) {
-  if (options.prune && !existsSync15(lockPath)) {
-    throw new Error(`Refusing to prune without an existing lockfile at ${path19.resolve(lockPath)}`);
+  if (options.prune && !existsSync16(lockPath)) {
+    throw new Error(`Refusing to prune without an existing lockfile at ${path20.resolve(lockPath)}`);
   }
-  const contentDir = path19.resolve(path19.dirname(lockPath), ".pixelkiln", "cache");
-  const remotePath = path19.resolve(cachePathFor(lockPath));
+  const contentDir = path20.resolve(path20.dirname(lockPath), ".pixelkiln", "cache");
+  const remotePath = path20.resolve(cachePathFor(lockPath));
   const referenced = new Set(
     Object.values(lock.entries).flatMap((entry) => entry.outputs.map((output) => output.sha256))
   );
@@ -6715,7 +7168,7 @@ async function inspectCaches(lock, lockPath, options = {}) {
     ]);
     for (const name of names) {
       try {
-        await rm7(path19.join(contentDir, name), { force: true });
+        await rm7(path20.join(contentDir, name), { force: true });
         removed.contentFiles++;
       } catch {
       }
@@ -6724,7 +7177,7 @@ async function inspectCaches(lock, lockPath, options = {}) {
       await saveCache(remotePath, { version: 1, hashes: {} });
       removed.resetRemoteHashCache = true;
     } else if (remoteHashes.invalidIds.length) {
-      const cache = parseCache(JSON.parse(await readFile13(remotePath, "utf8")));
+      const cache = parseCache(JSON.parse(await readFile14(remotePath, "utf8")));
       for (const id of remoteHashes.invalidIds) delete cache.hashes[id];
       removed.remoteHashEntries = remoteHashes.invalidIds.length;
       await saveCache(remotePath, cache);
@@ -6742,7 +7195,7 @@ async function inspectCaches(lock, lockPath, options = {}) {
 async function inspectContentCache(contentDir, referenced) {
   const report = {
     path: contentDir,
-    exists: existsSync15(contentDir),
+    exists: existsSync16(contentDir),
     files: 0,
     bytes: 0,
     valid: 0,
@@ -6763,12 +7216,12 @@ async function inspectContentCache(contentDir, referenced) {
       continue;
     }
     report.files++;
-    const file = path19.join(contentDir, entry.name);
+    const file = path20.join(contentDir, entry.name);
     const mediaType = mediaTypeFromExtension(entry.name);
     const expected = mediaType ? entry.name.slice(0, -4) : "";
     let bytes;
     try {
-      bytes = await readFile13(file);
+      bytes = await readFile14(file);
       report.bytes += bytes.length;
     } catch (err) {
       report.invalid.push({
@@ -6806,7 +7259,7 @@ async function inspectContentCache(contentDir, referenced) {
 async function inspectRemoteHashCache(remotePath) {
   const report = {
     path: remotePath,
-    exists: existsSync15(remotePath),
+    exists: existsSync16(remotePath),
     entries: 0,
     valid: 0,
     invalidIds: [],
@@ -6815,7 +7268,7 @@ async function inspectRemoteHashCache(remotePath) {
   if (!report.exists) return report;
   let cache;
   try {
-    cache = parseCache(JSON.parse(await readFile13(remotePath, "utf8")));
+    cache = parseCache(JSON.parse(await readFile14(remotePath, "utf8")));
   } catch (err) {
     report.error = err instanceof Error ? err.message : String(err);
     return report;
@@ -7086,8 +7539,8 @@ function isRecord2(value) {
 }
 
 // src/pick/salvage-server.ts
-import { mkdir as mkdir6, writeFile as writeFile8, readFile as readFile14 } from "fs/promises";
-import path20 from "path";
+import { mkdir as mkdir6, writeFile as writeFile8, readFile as readFile15 } from "fs/promises";
+import path21 from "path";
 
 // src/pick/salvage-sheet.ts
 var escapeHtml2 = (s) => s.replace(/[&<>"']/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" })[c]);
@@ -7252,7 +7705,7 @@ async function runSalvage(provider, orphans, ctx, opts = {}) {
   });
   const html = renderSalvageSheet(orphans, {
     styleId: ctx.styleId,
-    importDir: path20.relative(process.cwd(), ctx.importDir) || "."
+    importDir: path21.relative(process.cwd(), ctx.importDir) || "."
   });
   const byId = new Map(orphans.map((o) => [o.id, o]));
   const existingTags = new Map(orphans.map((o) => [o.id, o.tags]));
@@ -7281,9 +7734,9 @@ async function runSalvage(provider, orphans, ctx, opts = {}) {
             if (!buf.subarray(0, 8).equals(PNG_SIGNATURE2)) throw new Error("not a PNG");
             decodePng(buf);
             const assetId = idFromPrompt(orphan.prompt, taken);
-            const rel = path20.join("_salvaged", `${assetId}.png`);
-            const outFile = path20.resolve(ctx.importDir, rel);
-            await mkdir6(path20.dirname(outFile), { recursive: true });
+            const rel = path21.join("_salvaged", `${assetId}.png`);
+            const outFile = path21.resolve(ctx.importDir, rel);
+            await mkdir6(path21.dirname(outFile), { recursive: true });
             await writeFile8(outFile, buf);
             ctx.manifest.assets[assetId] = {
               prompt: orphan.prompt,
@@ -7314,7 +7767,7 @@ async function runSalvage(provider, orphans, ctx, opts = {}) {
               sourceUrl: durableSource,
               sourceUrls: durableSource ? [{ url: durableSource }] : [],
               outputs: [{
-                path: portableOutputPath(outFile, path20.dirname(ctx.manifestPath)),
+                path: portableOutputPath(outFile, path21.dirname(ctx.manifestPath)),
                 sha256: sha256(buf)
               }],
               submittedAt: orphan.createdAt,
@@ -7338,7 +7791,7 @@ async function runSalvage(provider, orphans, ctx, opts = {}) {
         }
       }
       await applyTags(provider, decisions, existingTags, { onProgress: log2 });
-      const raw = JSON.parse(await readFile14(ctx.manifestPath, "utf8"));
+      const raw = JSON.parse(await readFile15(ctx.manifestPath, "utf8"));
       for (const id of importedAssetIds) raw.assets[id] = ctx.manifest.assets[id];
       await writeFile8(ctx.manifestPath, JSON.stringify(raw, null, 2) + "\n");
       await saveLock(ctx.lockPath, ctx.lock);
@@ -7348,9 +7801,9 @@ async function runSalvage(provider, orphans, ctx, opts = {}) {
 }
 
 // src/recipes.ts
-import path21 from "path";
-import { existsSync as existsSync16 } from "fs";
-import { readdir as readdir3, readFile as readFile15 } from "fs/promises";
+import path22 from "path";
+import { existsSync as existsSync17 } from "fs";
+import { readdir as readdir3, readFile as readFile16 } from "fs/promises";
 import { fileURLToPath } from "url";
 import { z as z5 } from "zod";
 var SHA256_RE = /^[0-9a-f]{64}$/;
@@ -7359,7 +7812,7 @@ var VERSION_RE = /^\d+\.\d+\.\d+$/;
 var RECIPE_FILE = "pixelkiln.recipe.json";
 var RECIPE_DIR_TOKEN = "{{recipeDir}}";
 var PortablePathSchema = z5.string().min(1).refine((value) => {
-  if (value.includes("\\") || path21.posix.isAbsolute(value)) return false;
+  if (value.includes("\\") || path22.posix.isAbsolute(value)) return false;
   const parts = value.split("/");
   return !parts.includes("") && !parts.includes(".") && !parts.includes("..");
 }, "expected a portable relative path without '.', '..', or backslashes");
@@ -7394,10 +7847,13 @@ var RecipeSchema = z5.object({
     numImages: z5.number().int().min(1).max(16),
     bindings: z5.object({
       prompt: RecipeBindingSchema,
-      width: RecipeBindingSchema,
-      height: RecipeBindingSchema,
-      batchSize: RecipeBindingSchema,
-      seed: RecipeBindingSchema.optional()
+      width: RecipeBindingSchema.optional(),
+      height: RecipeBindingSchema.optional(),
+      batchSize: RecipeBindingSchema.optional(),
+      seed: RecipeBindingSchema.optional(),
+      sourceImage: RecipeBindingSchema.optional(),
+      maskImage: RecipeBindingSchema.optional(),
+      strength: RecipeBindingSchema.optional()
     }).strict()
   }).strict().optional(),
   quality: z5.object({
@@ -7532,10 +7988,10 @@ function message3(error) {
   return error instanceof Error ? error.message : String(error);
 }
 async function readRecipeFile(recipePath, bundled) {
-  const absolute = path21.resolve(recipePath);
+  const absolute = path22.resolve(recipePath);
   let raw;
   try {
-    raw = JSON.parse(await readFile15(absolute, "utf8"));
+    raw = JSON.parse(await readFile16(absolute, "utf8"));
   } catch (error) {
     throw new Error(`Could not read recipe ${absolute}: ${message3(error)}`, { cause: error });
   }
@@ -7546,13 +8002,13 @@ async function readRecipeFile(recipePath, bundled) {
 ` + parsed.error.issues.map((issue) => `  ${issue.path.join(".") || "$"}: ${issue.message}`).join("\n")
     );
   }
-  return { recipe: parsed.data, path: absolute, dir: path21.dirname(absolute), bundled };
+  return { recipe: parsed.data, path: absolute, dir: path22.dirname(absolute), bundled };
 }
 async function walkRecipeFiles(root) {
-  if (!existsSync16(root)) return [];
+  if (!existsSync17(root)) return [];
   const out = [];
   for (const entry of await readdir3(root, { withFileTypes: true })) {
-    const resolved = path21.join(root, entry.name);
+    const resolved = path22.join(root, entry.name);
     if (entry.isDirectory()) out.push(...await walkRecipeFiles(resolved));
     else if (entry.isFile() && entry.name === RECIPE_FILE) out.push(resolved);
   }
@@ -7563,7 +8019,7 @@ function bundledRecipeRoot() {
 }
 async function listBundledRecipes(root = bundledRecipeRoot()) {
   const recipes = await Promise.all(
-    (await walkRecipeFiles(path21.resolve(root))).map((file) => readRecipeFile(file, true))
+    (await walkRecipeFiles(path22.resolve(root))).map((file) => readRecipeFile(file, true))
   );
   return recipes.sort(
     (a, b) => a.recipe.id.localeCompare(b.recipe.id) || compareVersions(b.recipe.version, a.recipe.version)
@@ -7586,9 +8042,9 @@ function parseSelector(selector) {
   return { id: match[1], version: match[2] };
 }
 async function resolveRecipe(target, bundledRoot = bundledRecipeRoot()) {
-  const local = path21.resolve(target);
-  if (existsSync16(local)) {
-    const recipePath = path21.basename(local) === RECIPE_FILE ? local : path21.join(local, RECIPE_FILE);
+  const local = path22.resolve(target);
+  if (existsSync17(local)) {
+    const recipePath = path22.basename(local) === RECIPE_FILE ? local : path22.join(local, RECIPE_FILE);
     return readRecipeFile(recipePath, false);
   }
   if (target.startsWith(".") || target.startsWith("/") || target.includes("\\")) {
@@ -7602,8 +8058,8 @@ async function resolveRecipe(target, bundledRoot = bundledRecipeRoot()) {
   return matches[0];
 }
 async function verifyFile(root, file) {
-  const absolute = path21.resolve(root, ...file.path.split("/"));
-  if (!existsSync16(absolute)) {
+  const absolute = path22.resolve(root, ...file.path.split("/"));
+  if (!existsSync17(absolute)) {
     return { path: file.path, expectedSha256: file.sha256, actualSha256: null, status: "missing" };
   }
   const actualSha256 = await sha256File(absolute);
@@ -7618,7 +8074,7 @@ async function verifyRecipe(target, options = {}) {
   const loaded = await resolveRecipe(target, options.bundledRoot);
   const actualIntegrity = recipeDigest(loaded.recipe);
   const files = await Promise.all(loaded.recipe.files.map((file) => verifyFile(loaded.dir, file)));
-  const modelRoot = options.modelRoot ? path21.resolve(options.modelRoot) : null;
+  const modelRoot = options.modelRoot ? path22.resolve(options.modelRoot) : null;
   const models = modelRoot ? await Promise.all(loaded.recipe.models.map(async (model) => ({
     ...await verifyFile(modelRoot, model),
     source: model.source,
@@ -7652,7 +8108,7 @@ async function verifyRecipe(target, options = {}) {
   };
 }
 function renderStyle(style, destination, cwd) {
-  const portableDir = path21.relative(cwd, destination).split(path21.sep).join("/") || ".";
+  const portableDir = path22.relative(cwd, destination).split(path22.sep).join("/") || ".";
   const replace = (value) => {
     if (typeof value === "string") return value.replaceAll(RECIPE_DIR_TOKEN, portableDir);
     if (Array.isArray(value)) return value.map(replace);
@@ -7664,25 +8120,25 @@ function renderStyle(style, destination, cwd) {
   return replace(style);
 }
 async function installRecipe(target, options = {}) {
-  const cwd = path21.resolve(options.cwd ?? process.cwd());
+  const cwd = path22.resolve(options.cwd ?? process.cwd());
   const loaded = await resolveRecipe(target, options.bundledRoot);
   const verification = await verifyRecipe(loaded.path);
   if (!verification.ok) {
     throw new Error(`Recipe ${loaded.recipe.id}@${loaded.recipe.version} failed integrity verification.`);
   }
-  const destination = options.out ? path21.resolve(cwd, options.out) : path21.join(cwd, "pixelkiln-recipes", ...loaded.recipe.id.split("/"), loaded.recipe.version);
+  const destination = options.out ? path22.resolve(cwd, options.out) : path22.join(cwd, "pixelkiln-recipes", ...loaded.recipe.id.split("/"), loaded.recipe.version);
   const sources = [
     { path: RECIPE_FILE, source: loaded.path },
-    ...loaded.recipe.files.map((file) => ({ path: file.path, source: path21.join(loaded.dir, ...file.path.split("/")) }))
+    ...loaded.recipe.files.map((file) => ({ path: file.path, source: path22.join(loaded.dir, ...file.path.split("/")) }))
   ];
   const files = await Promise.all(sources.map(async (file) => ({
-    path: path21.join(destination, ...file.path.split("/")),
-    data: await readFile15(file.source)
+    path: path22.join(destination, ...file.path.split("/")),
+    data: await readFile16(file.source)
   })));
   if (!options.force) {
     for (const file of files) {
-      if (!existsSync16(file.path)) continue;
-      const current = await readFile15(file.path);
+      if (!existsSync17(file.path)) continue;
+      const current = await readFile16(file.path);
       if (!current.equals(file.data)) {
         throw new Error(
           `Recipe destination has local changes: ${file.path}. Choose another --out or pass --force to replace declared recipe files.`
@@ -7705,15 +8161,15 @@ async function installRecipe(target, options = {}) {
 }
 
 // src/pipeline/quality-regression.ts
-import path22 from "path";
-import { existsSync as existsSync17 } from "fs";
-import { readFile as readFile16 } from "fs/promises";
+import path23 from "path";
+import { existsSync as existsSync18 } from "fs";
+import { readFile as readFile17 } from "fs/promises";
 import { z as z6 } from "zod";
 var SHA256_RE2 = /^[0-9a-f]{64}$/;
 var HEX_RE = /^#[0-9a-f]{6}$/;
 var MAX_REDMEAN_DISTANCE = 765;
 var QualityPathSchema = z6.string().min(1).refine(
-  (value) => !path22.posix.isAbsolute(value) && !value.includes("\\"),
+  (value) => !path23.posix.isAbsolute(value) && !value.includes("\\"),
   "expected a portable relative path"
 );
 var DEFAULT_QUALITY_TOLERANCES = {
@@ -7860,10 +8316,10 @@ function measureDecodedImageQuality(png, digest2) {
   };
 }
 async function measureImageQuality(file) {
-  const absolute = path22.resolve(file);
+  const absolute = path23.resolve(file);
   let bytes;
   try {
-    bytes = await readFile16(absolute);
+    bytes = await readFile17(absolute);
   } catch (error) {
     throw new Error(`Cannot read quality image ${absolute}: ${message4(error)}`, { cause: error });
   }
@@ -7882,11 +8338,11 @@ function resolveQualityInputs(raw, inputsFilePath) {
   }
   const ids = parsed.data.map((entry) => entry.id);
   if (new Set(ids).size !== ids.length) throw new Error("--inputs contains a duplicate quality case id.");
-  const root = path22.dirname(path22.resolve(inputsFilePath));
+  const root = path23.dirname(path23.resolve(inputsFilePath));
   return parsed.data.map((entry) => ({
     id: entry.id,
-    file: path22.resolve(root, entry.path),
-    ...entry.record ? { record: path22.resolve(root, entry.record) } : {},
+    file: path23.resolve(root, entry.path),
+    ...entry.record ? { record: path23.resolve(root, entry.record) } : {},
     tolerances: QualityToleranceSchema.parse({
       ...DEFAULT_QUALITY_TOLERANCES,
       ...entry.tolerances
@@ -7894,7 +8350,7 @@ function resolveQualityInputs(raw, inputsFilePath) {
   }));
 }
 function portableRelative2(from, to) {
-  return path22.relative(from, path22.resolve(to)).split(path22.sep).join("/") || ".";
+  return path23.relative(from, path23.resolve(to)).split(path23.sep).join("/") || ".";
 }
 async function verifyRecordForImage(recordPath, imagePath) {
   const verification = await verifyArtifactBundle(recordPath);
@@ -7909,20 +8365,20 @@ async function verifyRecordForImage(recordPath, imagePath) {
   if (record.kind !== "refine" || options === null || typeof options !== "object" || options.schema !== "pixelkiln-quality") {
     throw new Error(`Quality record ${recordPath} is not a PixelKiln refinement record.`);
   }
-  const outputs = record.outputs.map((output) => path22.resolve(path22.dirname(recordPath), output.path));
-  if (!outputs.includes(path22.resolve(imagePath))) {
+  const outputs = record.outputs.map((output) => path23.resolve(path23.dirname(recordPath), output.path));
+  if (!outputs.includes(path23.resolve(imagePath))) {
     throw new Error(`Quality record ${recordPath} does not own ${imagePath}.`);
   }
 }
 async function snapshotQualityBaseline(inputs, baselinePath, options = {}) {
   if (!inputs.length) throw new Error("Cannot snapshot an empty quality baseline.");
-  const absolute = path22.resolve(baselinePath);
+  const absolute = path23.resolve(baselinePath);
   for (const input of inputs) {
-    if (path22.resolve(input.file) === absolute || input.record && path22.resolve(input.record) === absolute) {
+    if (path23.resolve(input.file) === absolute || input.record && path23.resolve(input.record) === absolute) {
       throw new Error(`Quality baseline output would overwrite an input: ${absolute}.`);
     }
   }
-  const root = path22.dirname(absolute);
+  const root = path23.dirname(absolute);
   const cases = [];
   for (const input of [...inputs].sort((a, b) => a.id.localeCompare(b.id))) {
     const expected = await measureImageQuality(input.file);
@@ -7949,8 +8405,8 @@ async function snapshotQualityBaseline(inputs, baselinePath, options = {}) {
     cases
   });
   const data = Buffer.from(JSON.stringify(baseline, null, 2) + "\n");
-  if (existsSync17(absolute) && !options.force) {
-    const current = await readFile16(absolute);
+  if (existsSync18(absolute) && !options.force) {
+    const current = await readFile17(absolute);
     if (!current.equals(data)) {
       throw new Error(`Quality baseline already exists with different content: ${absolute}. Pass --force to replace it.`);
     }
@@ -7959,10 +8415,10 @@ async function snapshotQualityBaseline(inputs, baselinePath, options = {}) {
   return { baseline, path: absolute, changed: result.changed.length > 0 };
 }
 async function readQualityBaseline(baselinePath) {
-  const absolute = path22.resolve(baselinePath);
+  const absolute = path23.resolve(baselinePath);
   let raw;
   try {
-    raw = JSON.parse(await readFile16(absolute, "utf8"));
+    raw = JSON.parse(await readFile17(absolute, "utf8"));
   } catch (error) {
     throw new Error(`Could not read quality baseline ${absolute}: ${message4(error)}`, { cause: error });
   }
@@ -8032,12 +8488,12 @@ function regressionViolations(expected, actual, tolerances) {
   return { violations, warnings };
 }
 async function checkQualityBaseline(baselinePath) {
-  const absolute = path22.resolve(baselinePath);
+  const absolute = path23.resolve(baselinePath);
   const baseline = await readQualityBaseline(absolute);
-  const root = path22.dirname(absolute);
+  const root = path23.dirname(absolute);
   const cases = [];
   for (const entry of baseline.cases) {
-    const file = path22.resolve(root, entry.file);
+    const file = path23.resolve(root, entry.file);
     let actual = null;
     const violations = [];
     const warnings = [];
@@ -8050,7 +8506,7 @@ async function checkQualityBaseline(baselinePath) {
       violations.push(message4(error));
     }
     if (entry.record) {
-      const recordPath = path22.resolve(root, entry.record.path);
+      const recordPath = path23.resolve(root, entry.record.path);
       try {
         const recordHash = await sha256File(recordPath);
         if (recordHash !== entry.record.sha256) violations.push("quality record hash changed");
@@ -8088,11 +8544,11 @@ async function checkQualityBaseline(baselinePath) {
 // src/cli.ts
 var log = (msg = "") => console.log(msg);
 async function provenanceFile(id, file) {
-  const absolute = path23.resolve(file);
+  const absolute = path24.resolve(file);
   return {
     id,
     path: absolute,
-    sha256: existsSync18(absolute) ? await sha256File(absolute) : null,
+    sha256: existsSync19(absolute) ? await sha256File(absolute) : null,
     included: true
   };
 }
@@ -8349,7 +8805,7 @@ function parseArgs(argv) {
   return {
     command,
     manifest,
-    lock: get("--lock") ?? path23.join(path23.dirname(path23.resolve(manifest)), "pixelkiln.lock.json"),
+    lock: get("--lock") ?? path24.join(path24.dirname(path24.resolve(manifest)), "pixelkiln.lock.json"),
     explicitLock: get("--lock"),
     styles: list("--style"),
     assets: list("--only"),
@@ -8497,7 +8953,17 @@ Examples
 `;
 function printPlan(plan) {
   const counts = summarize(plan);
-  const order = ["missing", "untracked", "stale", "failed", "recoverable", "in-flight", "orphaned", "ok"];
+  const order = [
+    "blocked",
+    "missing",
+    "untracked",
+    "stale",
+    "failed",
+    "recoverable",
+    "in-flight",
+    "orphaned",
+    "ok"
+  ];
   for (const state of order) {
     const items = plan.items.filter((i) => i.state === state);
     if (!items.length) continue;
@@ -8510,7 +8976,7 @@ function printPlan(plan) {
   }
   log(
     `
-  totals: ${counts.ok} ok \xB7 ${counts.missing} missing \xB7 ${counts.untracked} untracked \xB7 ${counts.stale} stale \xB7 ${counts["in-flight"]} in-flight \xB7 ${counts.orphaned} orphaned \xB7 ${counts.recoverable} recoverable \xB7 ${counts.failed} failed`
+  totals: ${counts.ok} ok \xB7 ${counts.blocked} blocked \xB7 ${counts.missing} missing \xB7 ${counts.untracked} untracked \xB7 ${counts.stale} stale \xB7 ${counts["in-flight"]} in-flight \xB7 ${counts.orphaned} orphaned \xB7 ${counts.recoverable} recoverable \xB7 ${counts.failed} failed`
   );
   if (plan.actionable.length) {
     for (const group of plan.groups) {
@@ -8604,10 +9070,10 @@ async function confirm(question, auto) {
   return answer === "y" || answer === "yes";
 }
 async function requireCompleteWorkspaceClaims(workspacePath) {
-  if (!existsSync18(workspacePath)) {
+  if (!existsSync19(workspacePath)) {
     throw new Error(`Workspace catalog not found: ${workspacePath}`);
   }
-  const dir = path23.dirname(path23.resolve(workspacePath));
+  const dir = path24.dirname(path24.resolve(workspacePath));
   const ws = await loadWorkspace(workspacePath);
   const diagnostics = validateWorkspace(ws, dir);
   const errors = diagnostics.filter((d) => d.level === "error");
@@ -8628,7 +9094,7 @@ async function main() {
   }
   if (args.command === "--version" || args.command === "-v") {
     const pkg = JSON.parse(
-      await readFile17(new URL("../package.json", import.meta.url), "utf8")
+      await readFile18(new URL("../package.json", import.meta.url), "utf8")
     );
     log(`${pkg.name} ${pkg.version}`);
     return;
@@ -8639,15 +9105,15 @@ async function main() {
       if (!args.out) throw new Error("quality snapshot needs --out <pixelkiln.quality.json>.");
       let raw;
       try {
-        raw = JSON.parse(await readFile17(path23.resolve(args.inputs), "utf8"));
+        raw = JSON.parse(await readFile18(path24.resolve(args.inputs), "utf8"));
       } catch (error) {
         throw new Error(
-          `Could not read quality inputs ${path23.resolve(args.inputs)}: ${error instanceof Error ? error.message : String(error)}`,
+          `Could not read quality inputs ${path24.resolve(args.inputs)}: ${error instanceof Error ? error.message : String(error)}`,
           { cause: error }
         );
       }
       const inputs = resolveQualityInputs(raw, args.inputs);
-      if (path23.resolve(args.inputs) === path23.resolve(args.out)) {
+      if (path24.resolve(args.inputs) === path24.resolve(args.out)) {
         throw new Error("quality snapshot --out must not overwrite its --inputs file.");
       }
       const result = await snapshotQualityBaseline(inputs, args.out, { force: args.force });
@@ -8660,7 +9126,7 @@ async function main() {
         }, null, 2));
       } else {
         log(
-          `  ${result.changed ? "wrote" : "unchanged"} ${path23.relative(process.cwd(), result.path)} (${result.baseline.cases.length} case(s))`
+          `  ${result.changed ? "wrote" : "unchanged"} ${path24.relative(process.cwd(), result.path)} (${result.baseline.cases.length} case(s))`
         );
         log(`  Review the tolerances, commit the baseline, then run quality check in CI.`);
       }
@@ -8755,14 +9221,14 @@ async function main() {
         }, null, 2));
       } else {
         log(`  installed ${result.recipe.id}@${result.recipe.version}`);
-        log(`  ${path23.relative(process.cwd(), result.destination) || "."}`);
+        log(`  ${path24.relative(process.cwd(), result.destination) || "."}`);
         log(`
   Add this entry under your manifest's styles object:`);
         log(JSON.stringify({ [result.styleId]: result.style }, null, 2));
         if (result.recipe.models.length) {
           log(`
   Models are not downloaded automatically. Verify them with:`);
-          log(`  pixelkiln recipe verify ${path23.relative(process.cwd(), result.destination)} --model-root <ComfyUI/models>`);
+          log(`  pixelkiln recipe verify ${path24.relative(process.cwd(), result.destination)} --model-root <ComfyUI/models>`);
         }
       }
       return;
@@ -8796,12 +9262,12 @@ async function main() {
           `  recovered ${result2.detection.columns}x${result2.detection.rows} native grid (${result2.detection.confidence}: ${result2.detection.consensus})`
         );
         log(`  enforced ${result2.palette.length}-color palette without dithering`);
-        log(`  wrote ${path23.relative(process.cwd(), result2.output)}`);
-        log(`  quality record: ${path23.relative(process.cwd(), result2.record)}`);
+        log(`  wrote ${path24.relative(process.cwd(), result2.output)}`);
+        log(`  quality record: ${path24.relative(process.cwd(), result2.record)}`);
         log(`
   Automated checks passed. Human 1\xD7 review is still required:`);
         log(
-          `    pixelkiln refine approve --from ${path23.relative(process.cwd(), result2.record)} --reviewer "Your Name"`
+          `    pixelkiln refine approve --from ${path24.relative(process.cwd(), result2.record)} --reviewer "Your Name"`
         );
       }
       return;
@@ -8821,21 +9287,21 @@ async function main() {
         note: args.note
       });
       if (args.json) log(JSON.stringify(result2, null, 2));
-      else log(`  approved ${path23.relative(process.cwd(), result2.output)} by ${args.reviewer.trim()}`);
+      else log(`  approved ${path24.relative(process.cwd(), result2.output)} by ${args.reviewer.trim()}`);
       return;
     }
     const result = await checkQualityRecord(args.from);
     if (args.json) {
       log(JSON.stringify(result, null, 2));
     } else {
-      log(`  ${result.safe ? "release-ready" : "not release-ready"}: ${path23.relative(process.cwd(), result.output || result.record)}`);
+      log(`  ${result.safe ? "release-ready" : "not release-ready"}: ${path24.relative(process.cwd(), result.output || result.record)}`);
       for (const reason of result.reasons) log(`    ${reason}`);
     }
     if (!result.safe) process.exitCode = 1;
     return;
   }
   if (args.command === "balance") {
-    loadEnvFiles(path23.dirname(path23.resolve(args.manifest)));
+    loadEnvFiles(path24.dirname(path24.resolve(args.manifest)));
     loadEnvFiles(process.cwd());
     const loaded2 = await loadManifest(args.manifest);
     const selectedProvider = accountProviderId(loaded2.manifest, args.provider, "balance");
@@ -8848,31 +9314,31 @@ async function main() {
   }
   if (args.command === "init") {
     if (!args.from) throw new Error("init needs --from <dir> pointing at your existing PNGs.");
-    const root = path23.resolve(args.from);
-    if (!existsSync18(root)) throw new Error(`No directory at ${root}`);
+    const root = path24.resolve(args.from);
+    if (!existsSync19(root)) throw new Error(`No directory at ${root}`);
     const generator = args.generator ?? "map";
     if (generator !== "1dir" && generator !== "map") {
       throw new Error(`--generator must be "1dir" or "map", got "${args.generator}".`);
     }
-    const target = path23.resolve(args.out ?? "pixelkiln.manifest.json");
+    const target = path24.resolve(args.out ?? "pixelkiln.manifest.json");
     const { assets, skipped } = await scanAssets(root, { exclude: args.exclude });
     if (!assets.length) throw new Error(`No PNGs found under ${root}`);
     const manifest = buildManifest(
-      args.name ?? path23.basename(path23.dirname(target)),
+      args.name ?? path24.basename(path24.dirname(target)),
       args.styles[0] ?? "base",
       generator,
-      path23.relative(path23.dirname(target), root) || ".",
+      path24.relative(path24.dirname(target), root) || ".",
       assets
     );
     await writeManifestFile(target, manifest);
-    log(`  scanned ${assets.length} PNG(s) under ${path23.relative(process.cwd(), root)}`);
+    log(`  scanned ${assets.length} PNG(s) under ${path24.relative(process.cwd(), root)}`);
     if (skipped.length) log(`  skipped ${skipped.length} unreadable file(s)`);
-    log(`  wrote ${path23.relative(process.cwd(), target)}`);
+    log(`  wrote ${path24.relative(process.cwd(), target)}`);
     log(`
   Prompts are intentionally empty. To recover the real ones from your`);
     log(`  PixelLab account instead of inventing them:`);
     log(`
-    pixelkiln adopt --manifest ${path23.relative(process.cwd(), target)} --write-prompts
+    pixelkiln adopt --manifest ${path24.relative(process.cwd(), target)} --write-prompts
 `);
     return;
   }
@@ -8920,10 +9386,10 @@ async function main() {
     if (args.primaryOnly || args.outputRoles.length) {
       throw new Error("--primary-only and --output-role require manifest-driven pack");
     }
-    const raw = JSON.parse(await readFile17(path23.resolve(args.inputs), "utf8"));
+    const raw = JSON.parse(await readFile18(path24.resolve(args.inputs), "utf8"));
     const inputs = resolvePackInputs(raw, args.inputs);
     const { png, atlas, skipped, sources } = packSprites(inputs, { columns: args.columns });
-    const base = path23.resolve(args.out.replace(/\.png$/, ""));
+    const base = path24.resolve(args.out.replace(/\.png$/, ""));
     const outputs = [
       { path: `${base}.png`, data: png },
       { path: `${base}.json`, data: JSON.stringify(atlas, null, 2) + "\n" }
@@ -8936,17 +9402,17 @@ async function main() {
     log(
       `  ${atlas.frames.length} sprite(s), ${atlas.sheet.width}x${atlas.sheet.height} in ${atlas.columns} column(s) \u2014 ${(png.length / 1024).toFixed(1)} KB`
     );
-    log(`    ${path23.relative(process.cwd(), base)}.png + .json + .pixelkiln.json`);
+    log(`    ${path24.relative(process.cwd(), base)}.png + .json + .pixelkiln.json`);
     for (const s of skipped) log(`    skipped ${s.id}: ${s.reason}`);
     return;
   }
   if (args.command === "workspace") {
-    const workspacePath = path23.resolve(args.workspace ?? "pixelkiln.workspace.json");
-    const dir = path23.dirname(workspacePath);
+    const workspacePath = path24.resolve(args.workspace ?? "pixelkiln.workspace.json");
+    const dir = path24.dirname(workspacePath);
     if (args.subcommand === "add") {
-      const manifestPath = path23.resolve(args.target);
+      const manifestPath = path24.resolve(args.target);
       const loadedTarget = await loadManifest(manifestPath);
-      const lockPath = args.explicitLock ? path23.resolve(args.explicitLock) : path23.join(path23.dirname(manifestPath), "pixelkiln.lock.json");
+      const lockPath = args.explicitLock ? path24.resolve(args.explicitLock) : path24.join(path24.dirname(manifestPath), "pixelkiln.lock.json");
       const ws = await loadWorkspace(workspacePath);
       const id = args.name ?? loadedTarget.manifest.name;
       if (ws.projects.some((p) => p.id === id)) {
@@ -8966,10 +9432,10 @@ async function main() {
         ...args.account ? { account: args.account } : {}
       };
       await saveWorkspace(workspacePath, { version: 1, projects: [...ws.projects, project] });
-      log(`  registered "${id}" in ${path23.relative(process.cwd(), workspacePath)}`);
+      log(`  registered "${id}" in ${path24.relative(process.cwd(), workspacePath)}`);
       log(`    manifest: ${project.manifest}`);
       log(`    lock:     ${project.lock}`);
-      if (!existsSync18(lockPath)) {
+      if (!existsSync19(lockPath)) {
         log(
           `  warning: no lockfile there yet \u2014 this project contributes no claims until one is generated`
         );
@@ -8978,7 +9444,7 @@ async function main() {
     }
     if (args.subcommand === "remove") {
       const ws = await loadWorkspace(workspacePath);
-      const resolvedTarget = path23.resolve(args.target);
+      const resolvedTarget = path24.resolve(args.target);
       const match = ws.projects.find(
         (p) => p.id === args.target || resolveProject(dir, p).manifestPath === resolvedTarget
       );
@@ -8989,11 +9455,11 @@ async function main() {
         version: 1,
         projects: ws.projects.filter((p) => p !== match)
       });
-      log(`  removed "${match.id}" from ${path23.relative(process.cwd(), workspacePath)}`);
+      log(`  removed "${match.id}" from ${path24.relative(process.cwd(), workspacePath)}`);
       return;
     }
     if (args.subcommand === "list") {
-      if (!existsSync18(workspacePath)) {
+      if (!existsSync19(workspacePath)) {
         throw new Error(`Workspace catalog not found: ${workspacePath}`);
       }
       const ws = await loadWorkspace(workspacePath);
@@ -9001,9 +9467,9 @@ async function main() {
       if (args.json) {
         log(JSON.stringify({ version: 1, workspace: workspacePath, projects: ws.projects, diagnostics }, null, 2));
       } else if (!ws.projects.length) {
-        log(`  no projects registered in ${path23.relative(process.cwd(), workspacePath)}`);
+        log(`  no projects registered in ${path24.relative(process.cwd(), workspacePath)}`);
       } else {
-        log(`  ${ws.projects.length} project(s) in ${path23.relative(process.cwd(), workspacePath)}:`);
+        log(`  ${ws.projects.length} project(s) in ${path24.relative(process.cwd(), workspacePath)}:`);
         for (const p of ws.projects) {
           log(`    ${p.id.padEnd(24)} ${p.manifest.padEnd(40)} (${p.provider}${p.account ? `, ${p.account}` : ""})`);
         }
@@ -9013,7 +9479,7 @@ async function main() {
       return;
     }
     if (args.subcommand === "status") {
-      if (!existsSync18(workspacePath)) {
+      if (!existsSync19(workspacePath)) {
         throw new Error(`Workspace catalog not found: ${workspacePath}`);
       }
       const ws = await loadWorkspace(workspacePath);
@@ -9021,7 +9487,7 @@ async function main() {
       if (args.json) {
         log(JSON.stringify({ ...report, workspace: workspacePath }, null, 2));
       } else {
-        log(`  workspace: ${path23.relative(process.cwd(), workspacePath)}`);
+        log(`  workspace: ${path24.relative(process.cwd(), workspacePath)}`);
         for (const p of report.projects) {
           if (p.error) {
             log(`
@@ -9067,14 +9533,14 @@ async function main() {
       return;
     }
   }
-  if (!existsSync18(path23.resolve(args.manifest))) {
+  if (!existsSync19(path24.resolve(args.manifest))) {
     throw new Error(
-      `No manifest at ${path23.resolve(args.manifest)}. Pass --manifest, or run \`pixelkiln init --from <dir>\`.`
+      `No manifest at ${path24.resolve(args.manifest)}. Pass --manifest, or run \`pixelkiln init --from <dir>\`.`
     );
   }
-  const manifestDir = path23.dirname(path23.resolve(args.manifest));
+  const manifestDir = path24.dirname(path24.resolve(args.manifest));
   const envFiles = [...loadEnvFiles(manifestDir)];
-  if (path23.resolve(process.cwd()) !== manifestDir) envFiles.push(...loadEnvFiles(process.cwd()));
+  if (path24.resolve(process.cwd()) !== manifestDir) envFiles.push(...loadEnvFiles(process.cwd()));
   const loaded = await loadManifest(args.manifest);
   let specs = await resolveSpecs(loaded, {
     styles: args.styles,
@@ -9167,7 +9633,7 @@ async function main() {
         log(`  ${item.state.padEnd(16)} ${item.key}  ${item.reason}`);
         if (item.state === "needs-approval") {
           log(
-            `    pixelkiln refine approve --from ${path23.relative(process.cwd(), item.record)} --reviewer "Your Name"`
+            `    pixelkiln refine approve --from ${path24.relative(process.cwd(), item.record)} --reviewer "Your Name"`
           );
         }
       }
@@ -9225,10 +9691,19 @@ async function main() {
           actionable: group.actionable.map((item) => item.key)
         })),
         actionable: plan.actionable.map((i) => i.key),
-        items: plan.items.map(({ key, state, reason, quality }) => ({
+        items: plan.items.map(({ key, state, reason, quality, spec }) => ({
           key,
           state,
           reason,
+          ...spec.revision ? {
+            revision: {
+              mode: spec.revision.mode,
+              from: spec.revision.sourceAssetId,
+              sourceSha256: spec.revision.sourceSha256,
+              ...spec.revision.maskSha256 ? { maskSha256: spec.revision.maskSha256 } : {},
+              ...spec.revision.strength == null ? {} : { strength: spec.revision.strength }
+            }
+          } : {},
           ...quality ? { quality: { state: quality.state, reason: quality.reason } } : {}
         }))
       }, null, 2));
@@ -9249,7 +9724,7 @@ async function main() {
       let intact = true;
       for (const output of entry.outputs) {
         const file = resolveOutputPath(output.path, item.spec.root);
-        if (!existsSync18(file) || await sha256File(file) !== output.sha256) {
+        if (!existsSync19(file) || await sha256File(file) !== output.sha256) {
           intact = false;
           break;
         }
@@ -9307,7 +9782,7 @@ async function main() {
     if (args.primaryOnly && args.outputRoles.length) {
       throw new Error("pack accepts either --primary-only or --output-role, not both");
     }
-    const manifestDir2 = path23.dirname(path23.resolve(args.manifest));
+    const manifestDir2 = path24.dirname(path24.resolve(args.manifest));
     const styleIds = args.styles.length ? args.styles : Object.keys(loaded.manifest.styles);
     for (const styleId of styleIds) {
       const packagingSpecs = await resolveSpecs(loaded, { styles: [styleId] });
@@ -9319,7 +9794,7 @@ async function main() {
         sourceOverrides: qualitySources
       });
       const style = loaded.manifest.styles[styleId];
-      const base = args.out ? path23.resolve(args.out.replace(/\.png$/, "")) : path23.resolve(manifestDir2, style.outDir, `${styleId}-sheet`);
+      const base = args.out ? path24.resolve(args.out.replace(/\.png$/, "")) : path24.resolve(manifestDir2, style.outDir, `${styleId}-sheet`);
       const outputs = [
         { path: `${base}.png`, data: png },
         { path: `${base}.json`, data: JSON.stringify(atlas, null, 2) + "\n" }
@@ -9346,13 +9821,13 @@ async function main() {
       log(
         `  ${styleId} \u2014 ${atlas.frames.length} sprite(s), ${atlas.sheet.width}x${atlas.sheet.height} in ${atlas.columns} column(s)`
       );
-      log(`    ${path23.relative(process.cwd(), base)}.png + .json + .pixelkiln.json`);
+      log(`    ${path24.relative(process.cwd(), base)}.png + .json + .pixelkiln.json`);
       for (const s of skipped) log(`    skipped ${s.id}: ${s.reason}`);
     }
     return;
   }
   if (args.command === "mount") {
-    const manifestDir2 = path23.dirname(path23.resolve(args.manifest));
+    const manifestDir2 = path24.dirname(path24.resolve(args.manifest));
     const styleIds = args.styles.length ? args.styles : Object.keys(loaded.manifest.styles);
     for (const styleId of styleIds) {
       const style = loaded.manifest.styles[styleId];
@@ -9389,7 +9864,7 @@ async function main() {
         sources,
         outputRoles
       );
-      const out = path23.resolve(manifestDir2, style.mount.out);
+      const out = path24.resolve(manifestDir2, style.mount.out);
       const metadata = out.replace(/\.png$/, "") + ".json";
       const companion = out.replace(/\.png$/, "") + ".pixelkiln.json";
       const outputs = [
@@ -9406,7 +9881,7 @@ async function main() {
           await provenanceFile("$lock", args.lock),
           ...qualityRecords,
           ...artifactSources.filter(
-            (source) => source.id !== "$base" || path23.resolve(source.path) !== out
+            (source) => source.id !== "$base" || path24.resolve(source.path) !== out
           )
         ],
         options: {
@@ -9419,7 +9894,7 @@ async function main() {
       log(
         `  ${styleId} \u2014 ${atlas.frames.length} cell(s) into ${atlas.sheet.width}x${atlas.sheet.height}` + (overBase ? ` over ${style.mount.base}` : " (new sheet)")
       );
-      log(`    ${path23.relative(process.cwd(), out)} + atlas/provenance JSON`);
+      log(`    ${path24.relative(process.cwd(), out)} + atlas/provenance JSON`);
       for (const s of skipped) log(`    skipped ${s.id}: ${s.reason}`);
     }
     return;
@@ -9475,7 +9950,7 @@ async function main() {
   }
   if (args.command === "export") {
     const format = args.format ?? "generic";
-    const manifestDir2 = path23.dirname(path23.resolve(args.manifest));
+    const manifestDir2 = path24.dirname(path24.resolve(args.manifest));
     const selected = specs.filter((spec) => {
       if (spec.generator !== "tiles") return false;
       if (args.styles.length && !args.styles.includes(spec.styleId)) return false;
@@ -9491,12 +9966,12 @@ async function main() {
     for (const spec of selected) {
       const entry = lock.entries[lockKey(spec.styleId, spec.assetId)];
       const style = loaded.manifest.styles[spec.styleId];
-      const defaultBase = path23.resolve(manifestDir2, style.outDir, `${spec.assetId}-tileset`);
-      const base = args.out ? path23.resolve(args.out.replace(/\.(?:png|json|tsj|tres)$/i, "")) : defaultBase;
+      const defaultBase = path24.resolve(manifestDir2, style.outDir, `${spec.assetId}-tileset`);
+      const base = args.out ? path24.resolve(args.out.replace(/\.(?:png|json|tsj|tres)$/i, "")) : defaultBase;
       const result = exportTileset(entry, spec, {
         format,
         manifestDir: manifestDir2,
-        imageName: path23.basename(`${base}.png`),
+        imageName: path24.basename(`${base}.png`),
         columns: args.columns
       });
       const outputs = [
@@ -9514,7 +9989,7 @@ async function main() {
           asset: spec.assetId,
           columns: args.columns ?? null,
           format,
-          image: path23.basename(`${base}.png`),
+          image: path24.basename(`${base}.png`),
           providerRules: result.generic.providerRules,
           style: spec.styleId,
           tileType: spec.tileType ?? null
@@ -9524,7 +9999,7 @@ async function main() {
         `  ${spec.styleId}/${spec.assetId} \u2014 ${result.generic.tiles.length} tile(s), ${result.generic.sheet.width}x${result.generic.sheet.height} (${format})`
       );
       log(
-        `    ${path23.relative(process.cwd(), base)}.png + ${path23.basename(base)}${result.extension} + .pixelkiln.json`
+        `    ${path24.relative(process.cwd(), base)}.png + ${path24.basename(base)}${result.extension} + .pixelkiln.json`
       );
     }
     return;
@@ -9574,12 +10049,12 @@ async function main() {
   tagged ${n} object(s) upstream`);
     }
     if (args.writePrompts) {
-      const { filled, stillEmpty } = await writePromptsBack(path23.resolve(args.manifest), lock, {
+      const { filled, stillEmpty } = await writePromptsBack(path24.resolve(args.manifest), lock, {
         onProgress: log,
         provider: provider.id,
         assetIds: specs.map((spec) => spec.assetId)
       });
-      log(`  recovered ${filled} prompt(s) into ${path23.relative(process.cwd(), args.manifest)}`);
+      log(`  recovered ${filled} prompt(s) into ${path24.relative(process.cwd(), args.manifest)}`);
       const reloaded = await loadManifest(args.manifest);
       const rebased = (await resolveSpecs(reloaded, {
         styles: args.styles,
@@ -9608,12 +10083,12 @@ async function main() {
     const provider = providerFor(selectedAccountProvider);
     const jsonMode = args.dryRun && args.json;
     const diag = jsonMode ? (msg = "") => console.error(msg) : log;
-    const ownLock = path23.resolve(args.lock);
+    const ownLock = path24.resolve(args.lock);
     let workspaceProjects = [];
     let workspaceDir = "";
     if (args.workspace) {
-      const workspacePath = path23.resolve(args.workspace);
-      workspaceDir = path23.dirname(workspacePath);
+      const workspacePath = path24.resolve(args.workspace);
+      workspaceDir = path24.dirname(workspacePath);
       const complete = await requireCompleteWorkspaceClaims(workspacePath);
       workspaceProjects = complete.ws.projects;
       for (const d of complete.diagnostics) diag(`  WARN  ${d.id}: ${d.message}`);
@@ -9622,12 +10097,12 @@ async function main() {
     const lockPaths = [
       .../* @__PURE__ */ new Set([
         ...workspaceLockPaths,
-        ...existsSync18(ownLock) ? [ownLock] : [],
-        ...args.claims.map((c) => path23.resolve(c))
+        ...existsSync19(ownLock) ? [ownLock] : [],
+        ...args.claims.map((c) => path24.resolve(c))
       ])
     ];
     diag(`  claim set (${lockPaths.length} lockfile(s)):`);
-    for (const p of lockPaths) diag(`    ${path23.relative(process.cwd(), p)}`);
+    for (const p of lockPaths) diag(`    ${path24.relative(process.cwd(), p)}`);
     if (!args.claims.length && !args.workspace) {
       diag(
         `
@@ -9635,7 +10110,7 @@ async function main() {
   pass every other project's lockfile via --claims a.json,b.json, or
   register every project in a workspace catalog and pass --workspace.`
       );
-    } else if (args.workspace && !workspaceProjects.some((p) => resolveProject(workspaceDir, p).manifestPath === path23.resolve(args.manifest))) {
+    } else if (args.workspace && !workspaceProjects.some((p) => resolveProject(workspaceDir, p).manifestPath === path24.resolve(args.manifest))) {
       diag(
         `
   This project's manifest is not registered in the workspace catalog. Its own
@@ -9719,7 +10194,7 @@ async function main() {
           manifestPath: loaded.path,
           manifest: accountManifest,
           styleId,
-          importDir: path23.resolve(loaded.root, style.outDir),
+          importDir: path24.resolve(loaded.root, style.outDir),
           lock,
           lockPath: args.lock
         },
@@ -9929,7 +10404,8 @@ async function main() {
         port: args.port,
         open: !args.noOpen,
         onProgress: log,
-        keys: providerSpecsForRun.map((spec) => lockKey(spec.styleId, spec.assetId))
+        keys: providerSpecsForRun.map((spec) => lockKey(spec.styleId, spec.assetId)),
+        specs: providerSpecsForRun
       });
       total.selected += res.selected;
       total.skipped += res.skipped;