pixelkiln 0.12.0 → 0.13.0

package/dist/cli.js

@@ -1403,6 +1403,8 @@ var StyleImageSchema = z2.object({
   path: z2.string()
 });
 var StyleSchema = z2.object({
+  /** Generation backend for this style. Omit to inherit the manifest default. */
+  provider: z2.string().min(1).optional(),
   // `map` is the default because it is 20-40x cheaper and correct for any
   // asset that is not going to be rotated or animated.
   generator: GeneratorSchema.default("map"),
@@ -1963,6 +1965,7 @@ function firstUrl(urls) {
 
 // src/providers/retrodiffusion.ts
 var DEFAULT_BASE_URL2 = "https://api.retrodiffusion.ai/v1";
+var SOURCE_PROTOCOL = "retrodiffusion:";
 var RetroDiffusionClient = class {
   constructor(token, baseUrl = DEFAULT_BASE_URL2, request = fetch) {
     this.token = token;
@@ -2042,7 +2045,7 @@ var RetroDiffusionProvider = class _RetroDiffusionProvider {
     return new _RetroDiffusionProvider(new RetroDiffusionClient(void 0));
   }
   static forDownloads() {
-    return _RetroDiffusionProvider.forOffline();
+    return new _RetroDiffusionProvider(new RetroDiffusionClient(process.env.RD_API_KEY));
   }
   supports(generator) {
     return generator === "map" || generator === "pixflux" || generator === "tiles" || generator === "animation";
@@ -2148,11 +2151,15 @@ var RetroDiffusionProvider = class _RetroDiffusionProvider {
     const urls = sources.map((source) => source.url);
     if (!urls.length) return { status: "failed", error: "Retro Diffusion task returned no images" };
     if (urls.length > 1) return { status: "review", candidateUrls: urls };
+    const durableSources = sources.map((source, index) => ({
+      ...source,
+      url: sourceRef2(jobId, index, mediaType)
+    }));
     return {
       status: "ready",
       objectId: `${jobId}#0`,
-      sourceUrl: urls[0],
-      sources,
+      sourceUrl: durableSources[0].url,
+      sources: durableSources,
       metadata: {
         balanceCost: task.result?.balance_cost ?? null,
         remainingBalance: task.result?.remaining_balance ?? null,
@@ -2171,9 +2178,26 @@ var RetroDiffusionProvider = class _RetroDiffusionProvider {
     if (task.status !== "succeeded") throw new Error(`Retro Diffusion task ${jobId} is not ready`);
     const url = resultSources(task.result, MediaType.PNG)[index]?.url;
     if (!url) throw new Error(`Retro Diffusion task ${jobId} has no candidate at index ${index}`);
-    return { objectId: `${jobId}#${index}`, sourceUrl: url };
+    return { objectId: `${jobId}#${index}`, sourceUrl: sourceRef2(jobId, index, MediaType.PNG) };
   }
   async download(url) {
+    if (url.startsWith(`${SOURCE_PROTOCOL}//`)) {
+      const reference = parseSourceRef(url);
+      const task = await this.client.task(reference.jobId);
+      if (task.status !== "succeeded") {
+        throw new Error(`Retro Diffusion task ${reference.jobId} is not ready`);
+      }
+      const source = resultSources(task.result, reference.mediaType)[reference.index]?.url;
+      if (!source) {
+        throw new Error(
+          `Retro Diffusion task ${reference.jobId} has no output at index ${reference.index}`
+        );
+      }
+      return this.downloadResolved(source);
+    }
+    return this.downloadResolved(url);
+  }
+  async downloadResolved(url) {
     const data = /^data:[^;]+;base64,(.+)$/.exec(url)?.[1];
     if (data) return Buffer.from(data, "base64");
     const response = await fetch(url);
@@ -2184,6 +2208,23 @@ var RetroDiffusionProvider = class _RetroDiffusionProvider {
     return { unit: "usd", remaining: await this.client.balance() };
   }
 };
+function sourceRef2(jobId, index, mediaType) {
+  const url = new URL("retrodiffusion://output");
+  url.searchParams.set("job", jobId);
+  url.searchParams.set("index", String(index));
+  url.searchParams.set("mediaType", mediaType);
+  return url.href;
+}
+function parseSourceRef(value) {
+  const url = new URL(value);
+  const jobId = url.searchParams.get("job");
+  const index = Number(url.searchParams.get("index"));
+  const rawMediaType = url.searchParams.get("mediaType");
+  if (url.protocol !== SOURCE_PROTOCOL || url.hostname !== "output" || !jobId || !Number.isInteger(index) || index < 0 || rawMediaType !== MediaType.PNG && rawMediaType !== MediaType.GIF) {
+    throw new Error("Invalid durable Retro Diffusion source reference");
+  }
+  return { jobId, index, mediaType: rawMediaType };
+}
 function retroOptions(spec) {
   return spec.providerOptions;
 }
@@ -2353,7 +2394,17 @@ ${unknownReferences.map((i) => `  ${i}`).join("\n")}`);
 }
 async function resolveSpecs(loaded, filter) {
   const { manifest, root } = loaded;
-  const activeProvider = filter?.provider ?? createProvider(manifest.provider, "offline");
+  const providerOverride = filter?.provider;
+  const providers = /* @__PURE__ */ new Map();
+  const providerFor = (id) => {
+    if (providerOverride) return providerOverride;
+    let provider = providers.get(id);
+    if (!provider) {
+      provider = createProvider(id, "offline");
+      providers.set(id, provider);
+    }
+    return provider;
+  };
   const specs = [];
   const styleIds = Object.keys(manifest.styles).filter(
     (id) => !filter?.styles?.length || filter.styles.includes(id)
@@ -2389,6 +2440,7 @@ async function resolveSpecs(loaded, filter) {
   }
   for (const styleId of styleIds) {
     const style = manifest.styles[styleId];
+    const activeProvider = providerFor(style.provider ?? manifest.provider);
     const rawProviderOptions = style.providerOptions[activeProvider.id] ?? {};
     const optionResolution = activeProvider.resolveOptions ? await activeProvider.resolveOptions(rawProviderOptions, { root, styleId }) : { options: rawProviderOptions };
     const providerOptions = optionResolution.options;
@@ -3132,13 +3184,39 @@ async function buildPlan(specs, lock, opts = {}) {
     items.push({ spec, key, state, reason });
   }
   const actionable = items.filter((i) => i.state === "missing" || i.state === "stale" || i.state === "failed");
-  const units = new Set(actionable.map((item) => item.spec.costUnit ?? "generations"));
-  if (units.size > 1) throw new Error("A single plan cannot combine incompatible provider cost units");
+  const groupsByProvider = /* @__PURE__ */ new Map();
+  for (const item of actionable) {
+    const provider = item.spec.provider;
+    const costUnit = item.spec.costUnit ?? "generations";
+    const group = groupsByProvider.get(provider);
+    if (group && group.costUnit !== costUnit) {
+      throw new Error(
+        `Provider "${provider}" returned mixed cost units (${group.costUnit}, ${costUnit})`
+      );
+    }
+    if (group) {
+      group.actionable.push(item);
+      group.cost += item.spec.cost;
+      group.candidates += item.spec.candidates;
+    } else {
+      groupsByProvider.set(provider, {
+        provider,
+        costUnit,
+        cost: item.spec.cost,
+        candidates: item.spec.candidates,
+        actionable: [item]
+      });
+    }
+  }
+  const groups = [...groupsByProvider.values()].sort((a, b) => a.provider.localeCompare(b.provider));
+  const fallbackUnits = new Set(specs.map((spec) => spec.costUnit));
+  const single = groups.length === 1 ? groups[0] : null;
   return {
     items,
     actionable,
-    cost: actionable.reduce((sum, i) => sum + i.spec.cost, 0),
-    costUnit: actionable[0]?.spec.costUnit ?? specs[0]?.costUnit ?? (specs.length ? "generations" : "free"),
+    groups,
+    cost: single?.cost ?? (groups.length ? null : 0),
+    costUnit: single?.costUnit ?? (groups.length || fallbackUnits.size > 1 ? null : fallbackUnits.values().next().value ?? (specs.length ? "generations" : "free")),
     candidates: actionable.reduce((sum, i) => sum + i.spec.candidates, 0)
   };
 }
@@ -3245,6 +3323,10 @@ async function submit(provider, loaded, items, lock, lockPath, opts = {}) {
       submittedAt: (/* @__PURE__ */ new Date()).toISOString(),
       cost: estimate.amount,
       costUnit: estimate.unit,
+      // Persist routing before the request starts. If the process stops while
+      // the provider is accepting work, a resumed run must not fall back to
+      // PixelLab (the legacy lock default) for another provider's entry.
+      provider: provider.id,
       downloadedAt: null
     });
     await saveLock(lockPath, lock);
@@ -3257,8 +3339,7 @@ async function submit(provider, loaded, items, lock, lockPath, opts = {}) {
         // A multi-candidate generator routes through review; record the parent
         // so `pick` knows where to look.
         reviewObjectId: estimate.candidates > 1 && !spec.tileFeature ? jobId : null,
-        status: "processing",
-        provider: provider.id
+        status: "processing"
       });
       inFlight.set(jobId, spec);
       submitted++;
@@ -3286,9 +3367,10 @@ async function poll(provider, lock, lockPath, opts = {}) {
   });
   const started = Date.now();
   const specByKey = new Map((opts.specs ?? []).map((s) => [lockKey(s.styleId, s.assetId), s]));
+  const selectedKeys = opts.specs ? new Set(specByKey.keys()) : null;
   const result = { review: 0, completed: 0, failed: 0, stillRunning: 0 };
   const pending = () => Object.entries(lock.entries).filter(
-    ([, e]) => e.jobId && (e.status === "pending" || e.status === "processing")
+    ([key, e]) => e.provider === provider.id && (!selectedKeys || selectedKeys.has(key)) && e.jobId && (e.status === "pending" || e.status === "processing")
   );
   while (pending().length > 0) {
     if (Date.now() - started > timeout) {
@@ -3343,6 +3425,45 @@ async function poll(provider, lock, lockPath, opts = {}) {
 import { existsSync as existsSync6 } from "fs";
 import { mkdir as mkdir2, readFile as readFile4, rename as rename2, rm as rm2, writeFile as writeFile2 } from "fs/promises";
 import path9 from "path";
+
+// src/source-url.ts
+var SENSITIVE_QUERY_KEYS = /* @__PURE__ */ new Set([
+  "access_token",
+  "apikey",
+  "api_key",
+  "auth",
+  "authorization",
+  "awsaccesskeyid",
+  "googleaccessid",
+  "key",
+  "sig"
+]);
+function isSensitiveSourceUrl(value) {
+  let parsed;
+  try {
+    parsed = new URL(value);
+  } catch {
+    return false;
+  }
+  if (parsed.username || parsed.password) return true;
+  for (const key of parsed.searchParams.keys()) {
+    const normalized = key.toLowerCase();
+    if (SENSITIVE_QUERY_KEYS.has(normalized) || normalized.includes("credential") || normalized.includes("signature") || normalized.includes("security-token") || normalized.includes("token")) return true;
+  }
+  return false;
+}
+function shouldPersistSourceUrl(value) {
+  let parsed;
+  try {
+    parsed = new URL(value);
+  } catch {
+    return true;
+  }
+  if (parsed.protocol === "data:" || parsed.protocol === "file:") return false;
+  return !isSensitiveSourceUrl(value);
+}
+
+// src/pipeline/fetch.ts
 async function fetchAssets(provider, specs, lock, lockPath, opts = {}) {
   const log2 = opts.onProgress ?? (() => {
   });
@@ -3351,6 +3472,7 @@ async function fetchAssets(provider, specs, lock, lockPath, opts = {}) {
   normalizeLockOutputPaths(lock, specs);
   const cacheDir = opts.cacheDir === false ? null : path9.resolve(opts.cacheDir ?? path9.join(path9.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);
@@ -3444,15 +3566,16 @@ async function fetchAssets(provider, specs, lock, lockPath, opts = {}) {
           await rename2(tmp, target);
           log2(`  wrote   ${path9.relative(process.cwd(), target)}`);
         }
+        const persistentSources = sources.filter((source) => shouldPersistSourceUrl(source.url));
         upsert(lock, key, {
           status: "downloaded",
           provider: provider.id,
           outputs,
-          // Inline providers can hand the pipeline a machine-local temp file.
-          // Once its bytes are in the durable content cache, retaining that
-          // path makes a committed lockfile non-portable and falsely suggests
-          // the source still exists on another checkout.
-          ...cacheDir && sources.every((source) => source.url.startsWith("file://")) ? { sourceUrl: null, sourceUrls: [] } : {},
+          // A finished lock may be committed. Inline bytes, machine-local
+          // paths, and credential-bearing signed URLs are useful while a
+          // download is retryable but must not survive successful ingestion.
+          sourceUrl: persistentSources[0]?.url ?? null,
+          sourceUrls: persistentSources,
           downloadedAt: (/* @__PURE__ */ new Date()).toISOString(),
           error: null
         });
@@ -3516,7 +3639,7 @@ async function pushTags(provider, specs, lock, opts = {}) {
   let tagged = 0;
   for (const [key, entry] of Object.entries(lock.entries)) {
     const spec = specByKey.get(key);
-    if (!spec || !entry.objectId) continue;
+    if (!spec || entry.provider !== provider.id || !entry.objectId) continue;
     if (entry.generator === "pixflux") continue;
     if (!provider.setTags) return tagged;
     try {
@@ -3622,30 +3745,51 @@ async function doctor(loaded, specs, lock, lockPath, opts = {}) {
     unsettled ? "warning" : "ok",
     unsettled ? `${unsettled} spec(s) are not current: ` + Object.entries(counts).filter(([, n]) => n > 0).map(([state, n]) => `${n} ${state}`).join(", ") : "every resolved spec is current"
   );
-  if (opts.offline) {
-    add("provider", "warning", "provider connectivity skipped (--dry-run)");
-  } else if (!opts.provider) {
-    add(
-      "provider",
-      "error",
-      opts.apiKeyPresent === false ? `${opts.credentialEnv ?? "PIXELLAB_API_KEY"} is not configured` : "provider is not configured"
-    );
-  } else if (!opts.provider.balance && !opts.provider.checkConnection) {
-    add("provider", "ok", `${opts.provider.id} configured; connectivity check unavailable`);
-  } else if (!opts.provider.balance) {
-    try {
-      await opts.provider.checkConnection();
-      add("provider", "ok", `${opts.provider.id} reachable; balance reporting unavailable`);
-    } catch (err) {
-      add("provider", "error", `provider connectivity failed: ${err instanceof Error ? err.message : String(err)}`);
-    }
-  } else {
-    const balanceFn = opts.provider.balance.bind(opts.provider);
-    try {
-      const balance = await balanceFn();
-      add("provider", "ok", `${opts.provider.id} reachable; ${balance.remaining} ${balance.unit} remaining`);
-    } catch (err) {
-      add("provider", "error", `provider connectivity failed: ${err instanceof Error ? err.message : String(err)}`);
+  const legacyTarget = !opts.providers;
+  const targets = opts.providers ?? [{
+    id: opts.provider?.id ?? "provider",
+    provider: opts.provider,
+    apiKeyPresent: opts.apiKeyPresent ?? Boolean(opts.provider),
+    credentialEnv: opts.credentialEnv
+  }];
+  for (const target of targets) {
+    const checkId = targets.length === 1 ? "provider" : `provider:${target.id}`;
+    if (opts.offline) {
+      add(checkId, "warning", `${target.id} connectivity skipped (--dry-run)`);
+    } else if (!target.provider) {
+      add(
+        checkId,
+        "error",
+        !target.apiKeyPresent ? `${target.credentialEnv ?? (legacyTarget ? "PIXELLAB_API_KEY" : `${target.id} credential`)} is not configured` : `${target.id} is not configured`
+      );
+    } else if (!target.provider.balance && !target.provider.checkConnection) {
+      add(checkId, "ok", `${target.id} configured; connectivity check unavailable`);
+    } else if (!target.provider.balance) {
+      try {
+        await target.provider.checkConnection();
+        add(checkId, "ok", `${target.id} reachable; balance reporting unavailable`);
+      } catch (err) {
+        add(
+          checkId,
+          "error",
+          `${legacyTarget ? "provider" : target.id} connectivity failed: ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
+    } else {
+      try {
+        const balance = await target.provider.balance();
+        add(
+          checkId,
+          "ok",
+          `${target.id} reachable; ${balance.remaining} ${balance.unit} remaining`
+        );
+      } catch (err) {
+        add(
+          checkId,
+          "error",
+          `${legacyTarget ? "provider" : target.id} connectivity failed: ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
     }
   }
   return { ok: !checks.some((c) => c.level === "error"), checks };
@@ -3797,6 +3941,7 @@ async function adopt(provider, specs, lock, lockPath, opts = {}) {
           ambiguous.push(`${key}: already mapped to ${existing.objectId}, also matches ${obj.id}`);
           continue;
         }
+        const durableSource = shouldPersistSourceUrl(url) ? url : null;
         upsert(lock, key, {
           styleId: spec.styleId,
           assetId: spec.assetId,
@@ -3813,7 +3958,8 @@ async function adopt(provider, specs, lock, lockPath, opts = {}) {
           candidateIndex: null,
           status: "downloaded",
           error: null,
-          sourceUrl: url,
+          sourceUrl: durableSource,
+          sourceUrls: durableSource ? [{ url: durableSource }] : [],
           outputs: [{ path: portableOutputPath(spec.outFile, spec.root), sha256: hash }],
           submittedAt: obj.createdAt,
           downloadedAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -3863,9 +4009,12 @@ async function tagAdopted(provider, specs, lock, opts = {}) {
 async function writePromptsBack(manifestPath, lock, opts = {}) {
   const log2 = opts.onProgress ?? (() => {
   });
+  const selectedAssets = opts.assetIds ? new Set(opts.assetIds) : null;
   const raw = JSON.parse(await readFile6(manifestPath, "utf8"));
   const best = /* @__PURE__ */ new Map();
   for (const entry of Object.values(lock.entries)) {
+    if (opts.provider && entry.provider !== opts.provider) continue;
+    if (selectedAssets && !selectedAssets.has(entry.assetId)) continue;
     if (!entry.objectId || !entry.prompt) continue;
     const current = best.get(entry.assetId);
     if (!current || entry.prompt.length > current.length) best.set(entry.assetId, entry.prompt);
@@ -3873,6 +4022,7 @@ async function writePromptsBack(manifestPath, lock, opts = {}) {
   let filled = 0;
   const stillEmpty = [];
   for (const [id, asset] of Object.entries(raw.assets)) {
+    if (selectedAssets && !selectedAssets.has(id)) continue;
     if (asset.prompt && asset.prompt.trim()) continue;
     const recovered = best.get(id);
     if (recovered) {
@@ -4188,8 +4338,10 @@ function serveReviewPage(opts) {
 async function runPicker(provider, lock, lockPath, opts = {}) {
   const log2 = opts.onProgress ?? (() => {
   });
+  const selectedKeys = opts.keys ? new Set(opts.keys) : null;
   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);
@@ -4355,7 +4507,10 @@ async function writeManifestFile(target, manifest) {
 import { readFile as readFile8 } from "fs/promises";
 import { existsSync as existsSync11 } from "fs";
 import path13 from "path";
-async function loadClaims(lockPaths) {
+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 (!existsSync11(p)) throw new Error(`Claim lockfile not found: ${p}`);
@@ -4366,9 +4521,13 @@ async function loadClaims(lockPaths) {
       throw new Error(`Claim lockfile is malformed: ${p}`);
     }
     for (const entry of Object.values(parsed.entries)) {
-      if (entry.objectId) claimed.add(entry.objectId);
-      if (entry.reviewObjectId) claimed.add(entry.reviewObjectId);
-      if (entry.jobId) claimed.add(entry.jobId);
+      if (opts.provider && entry.provider !== opts.provider) continue;
+      const add = (id) => {
+        if (id) claimed.add(opts.qualify ? providerClaimId(entry.provider, id) : id);
+      };
+      add(entry.objectId);
+      add(entry.reviewObjectId);
+      add(entry.jobId);
     }
   }
   return claimed;
@@ -4379,7 +4538,9 @@ async function findOrphans(provider, claimed, opts = {}) {
   const all = [];
   for await (const obj of requireList(provider)()) all.push(obj);
   log2(`  scanned ${all.length} object(s) on the account`);
-  const orphans = all.filter((o) => !claimed.has(o.id) && o.status === "completed" && o.previewUrl).map((o) => ({
+  const orphans = all.filter(
+    (o) => !claimed.has(o.id) && !claimed.has(providerClaimId(provider.id, o.id)) && o.status === "completed" && o.previewUrl
+  ).map((o) => ({
     id: o.id,
     prompt: o.prompt || "(no prompt recorded)",
     width: o.width,
@@ -4674,7 +4835,7 @@ async function workspaceClaims(ws, dir) {
     lockPaths.push(lockPath);
     let projectClaims;
     try {
-      projectClaims = await loadClaims([lockPath]);
+      projectClaims = await loadClaims([lockPath], { qualify: true });
     } catch (err) {
       throw new Error(
         `Project "${project.id}" lockfile is unreadable: ${err instanceof Error ? err.message : String(err)}`
@@ -4712,9 +4873,14 @@ async function workspaceStatus(ws, dir) {
       lock: lockPath
     };
     try {
-      const provider = createProvider(project.provider, "offline");
       const loaded = await loadManifest(manifestPath);
-      const specs = await resolveSpecs(loaded, { provider });
+      const specs = await resolveSpecs(loaded);
+      const providers = [...new Set(
+        Object.values(loaded.manifest.styles).map(
+          (style) => style.provider ?? loaded.manifest.provider
+        )
+      )].sort();
+      if (!providers.length) providers.push(loaded.manifest.provider);
       const lock = await loadLock(lockPath);
       normalizeLockOutputPaths(lock, specs);
       const plan = await buildPlan(specs, lock);
@@ -4728,6 +4894,8 @@ async function workspaceStatus(ws, dir) {
       }
       projects.push({
         ...base,
+        provider: providers.length === 1 ? providers[0] : project.provider,
+        providers,
         entries: Object.keys(lock.entries).length,
         byState,
         spendByUnit: spend,
@@ -4736,6 +4904,7 @@ async function workspaceStatus(ws, dir) {
     } catch (err) {
       projects.push({
         ...base,
+        providers: [project.provider],
         entries: 0,
         byState: emptyStateCounts(),
         spendByUnit: { generations: 0, usd: 0, free: 0 },
@@ -6332,6 +6501,7 @@ async function runSalvage(provider, orphans, ctx, opts = {}) {
               styles: [ctx.styleId],
               ...orphan.width === orphan.height ? { size: orphan.width } : { width: orphan.width, height: orphan.height }
             };
+            const durableSource = shouldPersistSourceUrl(orphan.previewUrl) ? orphan.previewUrl : null;
             upsert(ctx.lock, lockKey(ctx.styleId, assetId), {
               styleId: ctx.styleId,
               assetId,
@@ -6346,7 +6516,10 @@ async function runSalvage(provider, orphans, ctx, opts = {}) {
               candidateIndex: null,
               status: "downloaded",
               error: null,
-              sourceUrl: orphan.previewUrl,
+              // The bytes are already local. Do not turn a temporary signed
+              // review URL into a credential-bearing committed lock entry.
+              sourceUrl: durableSource,
+              sourceUrls: durableSource ? [{ url: durableSource }] : [],
               outputs: [{
                 path: portableOutputPath(outFile, path19.dirname(ctx.manifestPath)),
                 sha256: sha256(buf)
@@ -6463,6 +6636,13 @@ var RecipeSchema = z5.object({
     digest: z5.string().regex(SHA256_RE)
   }).strict()
 }).strict().superRefine((recipe, context) => {
+  if (recipe.style.provider && recipe.style.provider !== recipe.provider) {
+    context.addIssue({
+      code: z5.ZodIssueCode.custom,
+      path: ["style", "provider"],
+      message: "must match the recipe provider"
+    });
+  }
   const filePaths = recipe.files.map((file) => file.path);
   if (new Set(filePaths).size !== filePaths.length) {
     context.addIssue({ code: z5.ZodIssueCode.custom, path: ["files"], message: "duplicate file path" });
@@ -6718,13 +6898,16 @@ async function installRecipe(target, options = {}) {
     }
   }
   const written = await writeArtifactBundle(files);
+  const renderedStyle = renderStyle(loaded.recipe.style, destination, cwd);
   return {
     recipe: loaded.recipe,
     destination,
     changed: written.changed,
     unchanged: written.unchanged,
     styleId: loaded.recipe.styleId,
-    style: renderStyle(loaded.recipe.style, destination, cwd)
+    // A recipe snippet should remain correct when pasted into a manifest whose
+    // top-level default is another provider.
+    style: { ...renderedStyle, provider: renderedStyle.provider ?? loaded.recipe.provider }
   };
 }
 
@@ -7320,12 +7503,34 @@ function parseArgs(argv) {
     }
   }
   let budget;
-  const rawBudget = get("--budget");
-  if (rawBudget !== void 0) {
-    budget = Number(rawBudget);
-    if (!Number.isFinite(budget) || budget < 0) {
+  const providerBudgets = /* @__PURE__ */ Object.create(null);
+  const rawBudgets = rest.flatMap((token, index) => token === "--budget" ? [rest[index + 1]] : []);
+  for (const rawBudget of rawBudgets) {
+    const separator = rawBudget.indexOf("=");
+    if (separator >= 0) {
+      const providerId = rawBudget.slice(0, separator).trim();
+      const rawAmount = rawBudget.slice(separator + 1).trim();
+      const amount2 = Number(rawAmount);
+      if (!providerId || /[=\s]/.test(providerId) || !Number.isFinite(amount2) || amount2 < 0) {
+        throw new Error(
+          `--budget must be a non-negative number or provider=number, got "${rawBudget}".`
+        );
+      }
+      if (Object.hasOwn(providerBudgets, providerId)) {
+        throw new Error(`--budget repeats provider "${providerId}".`);
+      }
+      providerBudgets[providerId] = amount2;
+      continue;
+    }
+    const amount = Number(rawBudget);
+    if (!Number.isFinite(amount) || amount < 0) {
       throw new Error(`--budget must be a non-negative number, got "${rawBudget}".`);
     }
+    if (budget !== void 0) throw new Error("Only one unkeyed --budget may be passed.");
+    budget = amount;
+  }
+  if (budget !== void 0 && Object.keys(providerBudgets).length) {
+    throw new Error("Do not mix an unkeyed --budget with provider-keyed budgets.");
   }
   const manifest = get("--manifest") ?? "pixelkiln.manifest.json";
   const rawFormat = get("--format");
@@ -7358,6 +7563,7 @@ function parseArgs(argv) {
     force: rest.includes("--force"),
     yes: rest.includes("--yes") || rest.includes("-y"),
     budget,
+    providerBudgets,
     dryRun: rest.includes("--dry-run"),
     all: rest.includes("--all"),
     json: rest.includes("--json"),
@@ -7456,7 +7662,9 @@ Options
   --lock <path>       Default: pixelkiln.lock.json beside the manifest
   --style a,b         Restrict to these styles
   --only id1,id2      Restrict to these asset ids
-  --budget <n>        Refuse to spend more than n provider cost units
+  --budget <n|provider=n>  Refuse to exceed one provider ceiling; repeat keyed budgets
+                           for a mixed-provider run
+  --provider <id>     Choose the account for balance/adopt/salvage/purge in a mixed manifest
   --force             Regenerate; also replace changed recipe files or quality baselines
   --dry-run           Never spend; doctor also skips provider connectivity
   --all               salvage --dry-run: list every unclaimed object, not just the first 30
@@ -7510,13 +7718,73 @@ function printPlan(plan) {
   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`
   );
   if (plan.actionable.length) {
-    log(
-      `  would generate ${plan.actionable.length} asset(s) \u2014 ${formatCost(plan.costUnit, plan.cost)}, yielding ${plan.candidates} candidate/output image(s)`
-    );
+    for (const group of plan.groups) {
+      log(
+        `  ${group.provider}: ${group.actionable.length} asset(s) \u2014 ${formatCost(group.costUnit, group.cost)}, ${group.candidates} candidate/output image(s)`
+      );
+    }
   } else {
     log(`  nothing to generate`);
   }
 }
+function manifestProviderIds(manifest) {
+  return [...new Set(
+    Object.values(manifest.styles).map((style) => style.provider ?? manifest.provider)
+  )].sort();
+}
+function specsByRecordedProvider(specs, lock) {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const spec of specs) {
+    const key = lockKey(spec.styleId, spec.assetId);
+    const provider = lock.entries[key]?.provider ?? spec.provider;
+    grouped.set(provider, [...grouped.get(provider) ?? [], spec]);
+  }
+  return grouped;
+}
+function accountProviderId(manifest, requested, command) {
+  const providers = manifestProviderIds(manifest);
+  if (requested) {
+    if (!providers.includes(requested)) {
+      throw new Error(
+        `Provider "${requested}" is not used by this manifest. Used: ${providers.join(", ")}.`
+      );
+    }
+    return requested;
+  }
+  if (providers.length > 1) {
+    throw new Error(
+      `${command} is account-scoped and this manifest uses ${providers.join(", ")}. Pass --provider <id>.`
+    );
+  }
+  return providers[0] ?? manifest.provider;
+}
+function budgetsForPlan(plan, args) {
+  const providerIds = new Set(plan.groups.map((group) => group.provider));
+  const keyed = Object.entries(args.providerBudgets);
+  for (const [provider] of keyed) {
+    if (!providerIds.has(provider)) {
+      throw new Error(
+        `Budget names provider "${provider}", but this run has work only for ${[...providerIds].join(", ") || "no providers"}.`
+      );
+    }
+  }
+  if (plan.groups.length > 1 && args.budget !== void 0) {
+    throw new Error(
+      "A mixed-provider run needs provider-keyed budgets, for example --budget pixellab=40 --budget retrodiffusion=1.25."
+    );
+  }
+  const out = /* @__PURE__ */ new Map();
+  for (const group of plan.groups) {
+    const ceiling = args.providerBudgets[group.provider];
+    if (plan.groups.length > 1 && group.costUnit !== "free" && group.cost > 0 && ceiling === void 0) {
+      throw new Error(
+        `Mixed-provider run is missing --budget ${group.provider}=<amount> for ${formatCost(group.costUnit, group.cost)} of planned work.`
+      );
+    }
+    out.set(group.provider, ceiling ?? (plan.groups.length === 1 ? args.budget : void 0));
+  }
+  return out;
+}
 async function confirm(question, auto) {
   if (auto) return true;
   if (!process.stdin.isTTY) {
@@ -7766,7 +8034,8 @@ async function main() {
     loadEnvFiles(path22.dirname(path22.resolve(args.manifest)));
     loadEnvFiles(process.cwd());
     const loaded2 = await loadManifest(args.manifest);
-    const p = createProvider(loaded2.manifest.provider, "online");
+    const selectedProvider = accountProviderId(loaded2.manifest, args.provider, "balance");
+    const p = createProvider(selectedProvider, "online");
     const b = await requireBalance(p)();
     log(`  provider:  ${p.id}`);
     log(`  plan:      ${b.plan ?? "n/a"}`);
@@ -7955,8 +8224,10 @@ async function main() {
   ${p.id} \u2014 ERROR: ${p.error}`);
             continue;
           }
-          log(`
-  ${p.id}  (${p.provider}${p.account ? `, ${p.account}` : ""})`);
+          log(
+            `
+  ${p.id}  (${p.providers.join(" + ")}${p.account ? `, ${p.account}` : ""})`
+          );
           log(`    ${p.entries} lock entries`);
           for (const [state, n] of Object.entries(p.byState)) if (n) log(`      ${state.padEnd(12)} ${n}`);
           for (const [unit, amount] of Object.entries(p.spendByUnit).sort()) {
@@ -8001,12 +8272,34 @@ async function main() {
   const envFiles = [...loadEnvFiles(manifestDir)];
   if (path22.resolve(process.cwd()) !== manifestDir) envFiles.push(...loadEnvFiles(process.cwd()));
   const loaded = await loadManifest(args.manifest);
-  const estimator = createProvider(loaded.manifest.provider, "offline");
-  const specs = await resolveSpecs(loaded, {
+  let specs = await resolveSpecs(loaded, {
     styles: args.styles,
-    assets: args.assets,
-    provider: estimator
+    assets: args.assets
   });
+  const accountCommands = /* @__PURE__ */ new Set(["adopt", "salvage", "purge"]);
+  const selectedAccountProvider = accountCommands.has(args.command) ? accountProviderId(loaded.manifest, args.provider, args.command) : void 0;
+  if (args.provider && !selectedAccountProvider) {
+    throw new Error(
+      "--provider is only used by balance, adopt, salvage, purge, or workspace add."
+    );
+  }
+  if (selectedAccountProvider) {
+    specs = specs.filter((spec) => spec.provider === selectedAccountProvider);
+  }
+  const accountManifest = selectedAccountProvider ? {
+    ...loaded.manifest,
+    provider: selectedAccountProvider,
+    styles: Object.fromEntries(
+      Object.entries(loaded.manifest.styles).filter(
+        ([, style]) => (style.provider ?? loaded.manifest.provider) === selectedAccountProvider
+      )
+    )
+  } : loaded.manifest;
+  if (selectedAccountProvider && args.styles.some((styleId) => !accountManifest.styles[styleId])) {
+    throw new Error(
+      `Selected style is not assigned to provider "${selectedAccountProvider}".`
+    );
+  }
   const lock = await loadLock(args.lock);
   normalizeLockOutputPaths(lock, specs);
   if (args.command === "status") {
@@ -8031,14 +8324,23 @@ async function main() {
   }
   const plan = await buildPlan(specs, lock, { force: args.force });
   if (args.command === "doctor") {
-    const factory = providerFactory(loaded.manifest.provider);
-    const apiKeyPresent = !factory.credentialEnv || Boolean(process.env[factory.credentialEnv]);
-    const provider2 = !args.dryRun && apiKeyPresent ? createProvider(loaded.manifest.provider, "online") : void 0;
+    const selectedStyleIds = args.styles.length ? args.styles : Object.keys(loaded.manifest.styles);
+    const providerIds = [...new Set(
+      selectedStyleIds.map((styleId) => loaded.manifest.styles[styleId]?.provider ?? loaded.manifest.provider)
+    )].sort();
+    const providers2 = providerIds.map((id) => {
+      const factory = providerFactory(id);
+      const apiKeyPresent = !factory.credentialEnv || Boolean(process.env[factory.credentialEnv]);
+      return {
+        id,
+        apiKeyPresent,
+        credentialEnv: factory.credentialEnv,
+        provider: !args.dryRun && apiKeyPresent ? createProvider(id, "online") : void 0
+      };
+    });
     const report = await doctor(loaded, specs, lock, args.lock, {
-      provider: provider2,
-      offline: args.dryRun,
-      apiKeyPresent,
-      credentialEnv: factory.credentialEnv
+      providers: providers2,
+      offline: args.dryRun
     });
     if (args.json) {
       log(JSON.stringify(report, null, 2));
@@ -8058,6 +8360,13 @@ async function main() {
         cost: plan.cost,
         costUnit: plan.costUnit,
         candidates: plan.candidates,
+        groups: plan.groups.map((group) => ({
+          provider: group.provider,
+          cost: group.cost,
+          costUnit: group.costUnit,
+          candidates: group.candidates,
+          actionable: group.actionable.map((item) => item.key)
+        })),
         actionable: plan.actionable.map((i) => i.key),
         items: plan.items.map(({ key, state, reason }) => ({ key, state, reason }))
       }, null, 2));
@@ -8072,7 +8381,7 @@ async function main() {
     for (const item of plan.items) {
       if (item.state !== "stale") continue;
       const entry = lock.entries[item.key];
-      if (!entry || entry.outputs.length === 0) continue;
+      if (!entry || entry.provider !== item.spec.provider || entry.outputs.length === 0) continue;
       let intact = true;
       for (const output of entry.outputs) {
         const file = resolveOutputPath(output.path, item.spec.root);
@@ -8338,8 +8647,18 @@ async function main() {
     }
     return;
   }
-  const provider = args.command === "restore" || args.command === "fetch" && !args.tag ? createProvider(loaded.manifest.provider, "downloads") : createProvider(loaded.manifest.provider, "online");
+  const providerMode = args.command === "restore" || args.command === "fetch" && !args.tag ? "downloads" : "online";
+  const providers = /* @__PURE__ */ new Map();
+  const providerFor = (id) => {
+    let resolved = providers.get(id);
+    if (!resolved) {
+      resolved = createProvider(id, providerMode);
+      providers.set(id, resolved);
+    }
+    return resolved;
+  };
   if (args.command === "adopt") {
+    const provider = providerFor(selectedAccountProvider);
     log(`
   Reconciling account objects against files already on disk\u2026`);
     const res = await adopt(provider, specs, lock, args.lock, { onProgress: log });
@@ -8374,15 +8693,16 @@ async function main() {
     }
     if (args.writePrompts) {
       const { filled, stillEmpty } = await writePromptsBack(path22.resolve(args.manifest), lock, {
-        onProgress: log
+        onProgress: log,
+        provider: provider.id,
+        assetIds: specs.map((spec) => spec.assetId)
       });
       log(`  recovered ${filled} prompt(s) into ${path22.relative(process.cwd(), args.manifest)}`);
       const reloaded = await loadManifest(args.manifest);
-      const rebased = await resolveSpecs(reloaded, {
+      const rebased = (await resolveSpecs(reloaded, {
         styles: args.styles,
-        assets: args.assets,
-        provider
-      });
+        assets: args.assets
+      })).filter((spec) => spec.provider === provider.id);
       let n = 0;
       for (const spec of rebased) {
         const key = lockKey(spec.styleId, spec.assetId);
@@ -8403,6 +8723,7 @@ async function main() {
     return;
   }
   if (args.command === "salvage") {
+    const provider = providerFor(selectedAccountProvider);
     const jsonMode = args.dryRun && args.json;
     const diag = jsonMode ? (msg = "") => console.error(msg) : log;
     const ownLock = path22.resolve(args.lock);
@@ -8440,7 +8761,7 @@ async function main() {
   \`pixelkiln workspace add ${args.manifest}\` would keep it aggregated too.`
       );
     }
-    const claimed = await loadClaims(lockPaths);
+    const claimed = await loadClaims(lockPaths, { provider: provider.id });
     const { orphans, total } = await findOrphans(provider, claimed, { onProgress: diag });
     diag(`  ${claimed.size} claimed \xB7 ${orphans.length} unclaimed of ${total}`);
     if (!orphans.length) {
@@ -8454,8 +8775,8 @@ async function main() {
       workspaceProjects.map((p) => resolveProject(workspaceDir, p).manifestPath),
       args.claims
     );
-    const { matched, unmatched, elsewhere } = groupOrphansByStyle(orphans, loaded.manifest, siblings);
-    const multiStyle = Object.keys(loaded.manifest.styles).length > 1;
+    const { matched, unmatched, elsewhere } = groupOrphansByStyle(orphans, accountManifest, siblings);
+    const multiStyle = Object.keys(accountManifest.styles).length > 1;
     if (multiStyle) {
       diag(`
   by style (matched against each style's prompt prefix/suffix):`);
@@ -8495,7 +8816,7 @@ async function main() {
     }
     const rebaseline = async () => {
       const reloaded = await loadManifest(args.manifest);
-      const rebased = await resolveSpecs(reloaded, { provider });
+      const rebased = (await resolveSpecs(reloaded)).filter((spec) => spec.provider === provider.id);
       let n = 0;
       for (const spec of rebased) {
         const key = lockKey(spec.styleId, spec.assetId);
@@ -8508,13 +8829,13 @@ async function main() {
       if (n) log(`  baselined ${n} imported asset(s) against the manifest`);
     };
     const runOne = async (styleId, list) => {
-      const style = loaded.manifest.styles[styleId];
+      const style = accountManifest.styles[styleId];
       const res = await runSalvage(
         provider,
         list,
         {
           manifestPath: loaded.path,
-          manifest: loaded.manifest,
+          manifest: accountManifest,
           styleId,
           importDir: path22.resolve(loaded.root, style.outDir),
           lock,
@@ -8561,6 +8882,7 @@ async function main() {
     return;
   }
   if (args.command === "purge") {
+    const provider = providerFor(selectedAccountProvider);
     const doomed = [];
     for await (const obj of requireList(provider)()) {
       if (obj.tags.includes("pixelkiln:discard")) {
@@ -8604,8 +8926,13 @@ async function main() {
     return;
   }
   if (args.command === "tag") {
-    const n = await pushTags(provider, specs, lock, { onProgress: log });
-    log(`  tagged ${n} object(s)`);
+    let tagged = 0;
+    for (const [providerId, providerSpecsForRun] of specsByRecordedProvider(specs, lock)) {
+      tagged += await pushTags(providerFor(providerId), providerSpecsForRun, lock, {
+        onProgress: log
+      });
+    }
+    log(`  tagged ${tagged} object(s)`);
     return;
   }
   if (args.command === "submit" || args.command === "gen") {
@@ -8616,26 +8943,43 @@ async function main() {
       return;
     }
     if (plan.actionable.length) {
-      const balance = provider.balance ? await provider.balance() : null;
-      if (balance) {
-        log(`
-  balance: ${formatCost(balance.unit, balance.remaining)} remaining (${provider.id})`);
-        if (balance.unit !== plan.costUnit) {
-          throw new Error(
-            `Provider estimate unit ${plan.costUnit} does not match balance unit ${balance.unit}.`
+      const budgets = budgetsForPlan(plan, args);
+      const balances = /* @__PURE__ */ new Map();
+      for (const group of plan.groups) {
+        const groupProvider = providerFor(group.provider);
+        const balance = groupProvider.balance ? await groupProvider.balance() : null;
+        balances.set(group.provider, balance);
+        if (balance) {
+          log(
+            `
+  balance: ${formatCost(balance.unit, balance.remaining)} remaining (${group.provider})`
+          );
+          if (balance.unit !== group.costUnit) {
+            throw new Error(
+              `Provider ${group.provider} estimate unit ${group.costUnit} does not match balance unit ${balance.unit}.`
+            );
+          }
+          if (balance.unit !== "free" && group.cost > balance.remaining) {
+            throw new Error(
+              `${group.provider} needs ${formatCost(balance.unit, group.cost)} but only ${formatCost(balance.unit, balance.remaining)} remain.`
+            );
+          }
+        } else {
+          log(
+            `
+  ${group.provider} does not expose an account balance; enforcing its run budget`
           );
         }
-        if (balance.unit !== "free" && plan.cost > balance.remaining) {
+        const ceiling = budgets.get(group.provider);
+        if (ceiling !== void 0 && group.cost > ceiling) {
           throw new Error(
-            `This run needs ${formatCost(balance.unit, plan.cost)} but only ${formatCost(balance.unit, balance.remaining)} remain.`
+            `${group.provider} would spend ${formatCost(group.costUnit, group.cost)} but its budget is ${formatCost(group.costUnit, ceiling)}.`
           );
         }
-      } else {
-        log(`
-  ${provider.id} does not expose an account balance; enforcing the explicit run budget`);
       }
+      const spendSummary = plan.groups.map((group) => `${group.provider} ${formatCost(group.costUnit, group.cost)}`).join("; ");
       const ok = await confirm(
-        `  Spend ${formatCost(plan.costUnit, plan.cost)} on ${plan.actionable.length} asset(s)?`,
+        `  Spend ${spendSummary} on ${plan.actionable.length} asset(s)?`,
         args.yes
       );
       if (!ok) {
@@ -8644,69 +8988,104 @@ async function main() {
       }
       log(`
   submitting\u2026`);
-      const res = await submit(provider, loaded, plan.actionable, lock, args.lock, {
-        budget: args.budget,
-        onProgress: log
-      });
-      log(
-        `
-  submitted ${res.submitted}, failed ${res.failed}, estimated ${formatCost(res.unit, res.spent)}`
-      );
-      try {
-        const after = balance && provider.balance ? await provider.balance() : null;
-        if (!balance || !after) throw new Error("balance reporting is unsupported");
-        const measured = measureBalanceChange(balance, after);
-        if (measured) {
-          const movement = measured.credited ? `${formatCost(measured.unit, measured.credited)} credited` : `${formatCost(measured.unit, measured.spent)} consumed`;
-          log(`  provider-reported balance change: ${movement}`);
-        } else {
-          log(`  provider changed balance units during the run; no delta reported`);
+      for (const group of plan.groups) {
+        const groupProvider = providerFor(group.provider);
+        const res = await submit(groupProvider, loaded, group.actionable, lock, args.lock, {
+          budget: budgets.get(group.provider),
+          onProgress: log
+        });
+        log(
+          `
+  ${group.provider}: submitted ${res.submitted}, failed ${res.failed}, estimated ${formatCost(res.unit, res.spent)}`
+        );
+        try {
+          const before = balances.get(group.provider);
+          const after = before && groupProvider.balance ? await groupProvider.balance() : null;
+          if (!before || !after) throw new Error("balance reporting is unsupported");
+          const measured = measureBalanceChange(before, after);
+          if (measured) {
+            const movement = measured.credited ? `${formatCost(measured.unit, measured.credited)} credited` : `${formatCost(measured.unit, measured.spent)} consumed`;
+            log(`  ${group.provider} balance change: ${movement}`);
+          } else {
+            log(`  ${group.provider} changed balance units; no delta reported`);
+          }
+        } catch (err) {
+          log(
+            `  ${group.provider} balance recheck unavailable: ${err instanceof Error ? err.message : String(err)}`
+          );
         }
-      } catch (err) {
-        log(`  provider balance recheck unavailable: ${err instanceof Error ? err.message : String(err)}`);
+        if (res.failed) process.exitCode = 1;
       }
-      if (res.failed) process.exitCode = 1;
     }
     if (args.command === "submit") return;
   }
   if (args.command === "poll" || args.command === "gen") {
     log(`
   polling\u2026`);
-    const res = await poll(provider, lock, args.lock, { onProgress: log, specs });
-    log(`
-  ${res.completed} ready \xB7 ${res.review} awaiting selection \xB7 ${res.failed} failed`);
-    if (res.failed || res.stillRunning) process.exitCode = 1;
+    const total = { completed: 0, review: 0, failed: 0, stillRunning: 0 };
+    for (const [providerId, providerSpecsForRun] of specsByRecordedProvider(specs, lock)) {
+      const res = await poll(providerFor(providerId), lock, args.lock, {
+        onProgress: log,
+        specs: providerSpecsForRun
+      });
+      total.completed += res.completed;
+      total.review += res.review;
+      total.failed += res.failed;
+      total.stillRunning += res.stillRunning;
+    }
+    log(
+      `
+  ${total.completed} ready \xB7 ${total.review} awaiting selection \xB7 ${total.failed} failed`
+    );
+    if (total.failed || total.stillRunning) process.exitCode = 1;
     if (args.command === "poll") return;
   }
   if (args.command === "pick" || args.command === "gen") {
-    const res = await runPicker(provider, lock, args.lock, {
-      port: args.port,
-      open: !args.noOpen,
-      onProgress: log
-    });
-    if (res.selected === 0 && res.skipped === 0) {
+    const total = { selected: 0, skipped: 0 };
+    for (const [providerId, providerSpecsForRun] of specsByRecordedProvider(specs, lock)) {
+      const res = await runPicker(providerFor(providerId), lock, args.lock, {
+        port: args.port,
+        open: !args.noOpen,
+        onProgress: log,
+        keys: providerSpecsForRun.map((spec) => lockKey(spec.styleId, spec.assetId))
+      });
+      total.selected += res.selected;
+      total.skipped += res.skipped;
+    }
+    if (total.selected === 0 && total.skipped === 0) {
       log(`  nothing awaiting selection`);
     } else {
       log(`
-  selected ${res.selected}, left in review ${res.skipped}`);
+  selected ${total.selected}, left in review ${total.skipped}`);
     }
-    if (args.command === "gen" && res.skipped) process.exitCode = 1;
+    if (args.command === "gen" && total.skipped) process.exitCode = 1;
     if (args.command === "pick") return;
   }
   if (args.command === "fetch" || args.command === "restore" || args.command === "gen") {
     log(`
   downloading\u2026`);
-    const res = await fetchAssets(provider, specs, lock, args.lock, {
-      onProgress: log,
-      repair: args.command === "restore"
-    });
-    log(`
-  downloaded ${res.downloaded}, skipped ${res.skipped}, failed ${res.failed}`);
-    if (res.failed) process.exitCode = 1;
-    if (args.tag) {
-      const n = await pushTags(provider, specs, lock, { onProgress: log });
-      log(`  tagged ${n} object(s) upstream`);
+    const total = { downloaded: 0, skipped: 0, failed: 0, tagged: 0 };
+    for (const [providerId, providerSpecsForRun] of specsByRecordedProvider(specs, lock)) {
+      const groupProvider = providerFor(providerId);
+      const res = await fetchAssets(groupProvider, providerSpecsForRun, lock, args.lock, {
+        onProgress: log,
+        repair: args.command === "restore"
+      });
+      total.downloaded += res.downloaded;
+      total.skipped += res.skipped;
+      total.failed += res.failed;
+      if (args.tag) {
+        total.tagged += await pushTags(groupProvider, providerSpecsForRun, lock, {
+          onProgress: log
+        });
+      }
     }
+    log(
+      `
+  downloaded ${total.downloaded}, skipped ${total.skipped}, failed ${total.failed}`
+    );
+    if (total.failed) process.exitCode = 1;
+    if (args.tag) log(`  tagged ${total.tagged} object(s) upstream`);
     await saveLock(args.lock, lock);
     log(`  lockfile written: ${args.lock}`);
     return;