pixelkiln 0.2.0 → 0.3.0

package/dist/cli.js

@@ -1,9 +1,9 @@
 #!/usr/bin/env node
 
 // src/cli.ts
-import path16 from "path";
-import { existsSync as existsSync14 } from "fs";
-import { readFile as readFile13 } from "fs/promises";
+import path18 from "path";
+import { existsSync as existsSync15 } from "fs";
+import { readFile as readFile14 } from "fs/promises";
 
 // src/env.ts
 import { readFileSync, existsSync } from "fs";
@@ -154,11 +154,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(path17, init, attempt = 0) {
+  async request(path19, init, attempt = 0) {
     const auth = this.apiKey.startsWith("Bearer ") ? this.apiKey : `Bearer ${this.apiKey}`;
     let res;
     try {
-      res = await fetch(`${BASE}${path17}`, {
+      res = await fetch(`${BASE}${path19}`, {
         ...init,
         signal: init?.signal ?? AbortSignal.timeout(this.timeoutMs),
         headers: {
@@ -170,24 +170,24 @@ var PixelLabClient = class {
     } catch (err) {
       if (attempt < MAX_RETRIES) {
         await sleep(backoffMs(attempt));
-        return this.request(path17, init, attempt + 1);
+        return this.request(path19, 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(path17, init, attempt + 1);
+      return this.request(path19, init, attempt + 1);
     }
     const text = await res.text();
     if (!res.ok) {
-      throw new PixelLabError(`${init?.method ?? "GET"} ${path17} \u2192 ${res.status}`, res.status, text);
+      throw new PixelLabError(`${init?.method ?? "GET"} ${path19} \u2192 ${res.status}`, res.status, text);
     }
     if (!text) return {};
     try {
       return JSON.parse(text);
     } catch {
-      throw new Error(`${init?.method ?? "GET"} ${path17} returned invalid JSON`);
+      throw new Error(`${init?.method ?? "GET"} ${path19} returned invalid JSON`);
     }
   }
   async balance() {
@@ -1353,8 +1353,8 @@ import { readFile } from "fs/promises";
 function sha256(data) {
   return createHash("sha256").update(data).digest("hex");
 }
-async function sha256File(path17) {
-  return sha256(await readFile(path17));
+async function sha256File(path19) {
+  return sha256(await readFile(path19));
 }
 function specHash(spec, styleImageHashes) {
   return sha256(
@@ -2715,10 +2715,10 @@ function isSha256Hash(value) {
 function parseCache(value) {
   return HashCacheSchema.parse(value);
 }
-async function loadCache(path17) {
-  if (!existsSync8(path17)) return { version: 1, hashes: {} };
+async function loadCache(path19) {
+  if (!existsSync8(path19)) return { version: 1, hashes: {} };
   try {
-    const parsed = HashCacheSchema.safeParse(JSON.parse(await readFile5(path17, "utf8")));
+    const parsed = HashCacheSchema.safeParse(JSON.parse(await readFile5(path19, "utf8")));
     if (!parsed.success) return { version: 1, hashes: {} };
     return {
       version: 1,
@@ -2730,18 +2730,18 @@ async function loadCache(path17) {
     return { version: 1, hashes: {} };
   }
 }
-async function saveCache(path17, cache) {
+async function saveCache(path19, 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 mkdir3(pathModule.dirname(pathModule.resolve(path17)), { recursive: true });
-  const tmp = `${path17}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
+  await mkdir3(pathModule.dirname(pathModule.resolve(path19)), { recursive: true });
+  const tmp = `${path19}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
   try {
     await writeFile3(tmp, JSON.stringify({ version: 1, hashes: sorted }, null, 2) + "\n");
-    await rename3(tmp, path17);
+    await rename3(tmp, path19);
   } finally {
     await rm3(tmp, { force: true });
   }
@@ -3382,6 +3382,7 @@ async function writeManifestFile(target, manifest) {
 // src/pipeline/salvage.ts
 import { readFile as readFile8 } from "fs/promises";
 import { existsSync as existsSync11 } from "fs";
+import path12 from "path";
 async function loadClaims(lockPaths) {
   const claimed = /* @__PURE__ */ new Set();
   for (const p of lockPaths) {
@@ -3429,6 +3430,26 @@ function matchStyleByPattern(prompt, manifest) {
   }
   return null;
 }
+async function loadSiblingManifests(ownManifestPath, workspaceManifestPaths, claimPaths) {
+  const own = path12.resolve(ownManifestPath);
+  const siblingManifestPaths = [
+    .../* @__PURE__ */ new Set([
+      ...workspaceManifestPaths,
+      ...claimPaths.map((c) => path12.join(path12.dirname(path12.resolve(c)), "pixelkiln.manifest.json"))
+    ])
+  ];
+  const siblings = [];
+  for (const siblingManifestPath of siblingManifestPaths) {
+    if (path12.resolve(siblingManifestPath) === own) continue;
+    if (!existsSync11(siblingManifestPath)) continue;
+    try {
+      const { manifest } = await loadManifest(siblingManifestPath);
+      siblings.push({ label: path12.basename(path12.dirname(siblingManifestPath)), manifest });
+    } catch {
+    }
+  }
+  return siblings;
+}
 function groupOrphansByStyle(orphans, manifest, siblings = []) {
   const matched = /* @__PURE__ */ new Map();
   const elsewhere = /* @__PURE__ */ new Map();
@@ -3538,10 +3559,237 @@ async function applyTags(provider, decisions, existing, opts = {}) {
   return { tagged, failed };
 }
 
-// src/pipeline/audit.ts
-import { readFile as readFile9 } from "fs/promises";
+// src/workspace.ts
+import { mkdir as mkdir4, readFile as readFile9, rename as rename4, rm as rm4, writeFile as writeFile6 } from "fs/promises";
 import { existsSync as existsSync12 } from "fs";
-import path12 from "path";
+import path13 from "path";
+import { z as z4 } from "zod";
+var WorkspaceProjectSchema = z4.object({
+  id: z4.string().min(1),
+  /** Manifest path, relative to the catalog file's own directory. */
+  manifest: z4.string().min(1),
+  /** Lockfile path, relative to the catalog file's own directory. */
+  lock: z4.string().min(1),
+  provider: z4.string().min(1).default("pixellab"),
+  /** Free-form label for a shared account, e.g. distinguishing sandboxes. */
+  account: z4.string().optional()
+}).strict();
+var WorkspaceSchema = z4.object({
+  version: z4.literal(1),
+  projects: z4.array(WorkspaceProjectSchema).default([])
+}).strict();
+function parseWorkspace(raw) {
+  const parsed = WorkspaceSchema.safeParse(raw);
+  if (parsed.success) return parsed.data;
+  throw new Error(
+    `Workspace catalog is not valid v1:
+${parsed.error.issues.slice(0, 5).map((i) => `  ${i.path.join(".")}: ${i.message}`).join("\n")}`
+  );
+}
+async function loadWorkspace(workspacePath) {
+  if (!existsSync12(workspacePath)) return { version: 1, projects: [] };
+  let raw;
+  try {
+    raw = JSON.parse(await readFile9(workspacePath, "utf8"));
+  } catch (err) {
+    throw new Error(
+      `Workspace catalog at ${workspacePath} is malformed:
+${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+  return parseWorkspace(raw);
+}
+async function saveWorkspace(workspacePath, ws) {
+  const sorted = {
+    version: 1,
+    projects: [...ws.projects].sort((a, b) => a.id.localeCompare(b.id))
+  };
+  await mkdir4(path13.dirname(path13.resolve(workspacePath)), { recursive: true });
+  const tmp = `${workspacePath}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
+  try {
+    await writeFile6(tmp, JSON.stringify(sorted, null, 2) + "\n");
+    await rename4(tmp, workspacePath);
+  } finally {
+    await rm4(tmp, { force: true });
+  }
+}
+function toPortablePath(dir, absolute) {
+  return path13.relative(dir, absolute).split(path13.sep).join("/");
+}
+function resolveProject(dir, project) {
+  return {
+    manifestPath: path13.resolve(dir, project.manifest.split("/").join(path13.sep)),
+    lockPath: path13.resolve(dir, project.lock.split("/").join(path13.sep))
+  };
+}
+function validateWorkspace(ws, dir) {
+  const diagnostics = [];
+  const idCounts = /* @__PURE__ */ new Map();
+  const lockOwners = /* @__PURE__ */ new Map();
+  const manifestOwners = /* @__PURE__ */ new Map();
+  for (const project of ws.projects) {
+    idCounts.set(project.id, (idCounts.get(project.id) ?? 0) + 1);
+    const { manifestPath, lockPath } = resolveProject(dir, project);
+    lockOwners.set(lockPath, [...lockOwners.get(lockPath) ?? [], project.id]);
+    manifestOwners.set(manifestPath, [...manifestOwners.get(manifestPath) ?? [], project.id]);
+    if (path13.isAbsolute(project.manifest) || path13.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 (!existsSync12(manifestPath)) {
+      diagnostics.push({
+        id: "missing-manifest",
+        level: "error",
+        message: `project "${project.id}" manifest not found: ${manifestPath}`
+      });
+    }
+    if (!existsSync12(lockPath)) {
+      diagnostics.push({
+        id: "missing-lock",
+        level: "error",
+        message: `project "${project.id}" lockfile not found: ${lockPath}`
+      });
+    }
+  }
+  for (const [id, count] of idCounts) {
+    if (count > 1) {
+      diagnostics.push({
+        id: "duplicate-id",
+        level: "error",
+        message: `project id "${id}" is registered ${count} times`
+      });
+    }
+  }
+  for (const [lockPath, ids] of lockOwners) {
+    if (ids.length > 1) {
+      diagnostics.push({
+        id: "duplicate-lock",
+        level: "error",
+        message: `${ids.join(", ")} all register the same lockfile: ${lockPath}`
+      });
+    }
+  }
+  for (const [manifestPath, ids] of manifestOwners) {
+    if (ids.length > 1) {
+      diagnostics.push({
+        id: "duplicate-manifest",
+        level: "warning",
+        message: `${ids.join(", ")} share manifest ${manifestPath} \u2014 expected only when they are variant lockfiles beside one manifest`
+      });
+    }
+  }
+  const providers = new Set(ws.projects.map((p) => p.provider));
+  if (providers.size > 1) {
+    diagnostics.push({
+      id: "mixed-provider",
+      level: "warning",
+      message: `registered projects use different providers: ${[...providers].sort().join(", ")} \u2014 spend totals are kept separate per unit, but confirm this is intentional`
+    });
+  }
+  return diagnostics;
+}
+
+// src/pipeline/workspace.ts
+async function workspaceClaims(ws, dir) {
+  const lockPaths = [];
+  const byProject = {};
+  const claimed = /* @__PURE__ */ new Set();
+  for (const project of ws.projects) {
+    const { lockPath } = resolveProject(dir, project);
+    lockPaths.push(lockPath);
+    let projectClaims;
+    try {
+      projectClaims = await loadClaims([lockPath]);
+    } catch (err) {
+      throw new Error(
+        `Project "${project.id}" lockfile is unreadable: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+    byProject[project.id] = projectClaims.size;
+    for (const id of projectClaims) claimed.add(id);
+  }
+  return { claimed, byProject, lockPaths };
+}
+function emptyStateCounts() {
+  return {
+    ok: 0,
+    missing: 0,
+    untracked: 0,
+    stale: 0,
+    orphaned: 0,
+    "in-flight": 0,
+    recoverable: 0,
+    failed: 0
+  };
+}
+async function workspaceStatus(ws, dir) {
+  const diagnostics = validateWorkspace(ws, dir);
+  const provider = PixelLabProvider.forOffline();
+  const projects = [];
+  const totalsByState = emptyStateCounts();
+  const totalsSpend = { generations: 0, usd: 0, free: 0 };
+  for (const project of ws.projects) {
+    const { manifestPath, lockPath } = resolveProject(dir, project);
+    const base = {
+      id: project.id,
+      provider: project.provider,
+      account: project.account ?? null,
+      manifest: manifestPath,
+      lock: lockPath
+    };
+    try {
+      const loaded = await loadManifest(manifestPath);
+      const specs = await resolveSpecs(loaded, { provider });
+      const lock = await loadLock(lockPath);
+      normalizeLockOutputPaths(lock, specs);
+      const plan = await buildPlan(specs, lock);
+      const byState = summarize(plan);
+      const spend = spendByUnit(lock);
+      for (const state of Object.keys(byState)) {
+        totalsByState[state] += byState[state];
+      }
+      for (const unit of Object.keys(spend)) {
+        totalsSpend[unit] += spend[unit];
+      }
+      projects.push({
+        ...base,
+        entries: Object.keys(lock.entries).length,
+        byState,
+        spendByUnit: spend,
+        error: null
+      });
+    } catch (err) {
+      projects.push({
+        ...base,
+        entries: 0,
+        byState: emptyStateCounts(),
+        spendByUnit: { generations: 0, usd: 0, free: 0 },
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }
+  let claims = 0;
+  try {
+    claims = (await workspaceClaims(ws, dir)).claimed.size;
+  } catch {
+  }
+  return {
+    version: 1,
+    safe: !diagnostics.some((d) => d.level === "error") && projects.every((p) => !p.error),
+    dir,
+    projects,
+    totals: { byState: totalsByState, spendByUnit: totalsSpend, claims },
+    diagnostics
+  };
+}
+
+// src/pipeline/audit.ts
+import { readFile as readFile10 } from "fs/promises";
+import { existsSync as existsSync13 } from "fs";
+import path14 from "path";
 function colorDistance(a, b) {
   const rmean = (a.r + b.r) / 2;
   const dr = a.r - b.r;
@@ -3586,12 +3834,12 @@ async function auditStyle(loaded, specs, styleId, lock) {
   const unreadable = [];
   for (const spec of mine) {
     for (const output of resolveSpecOutputs(spec, lock, loaded.root)) {
-      if (!existsSync12(output.absolutePath)) {
+      if (!existsSync13(output.absolutePath)) {
         missing.push(output.id);
         continue;
       }
       try {
-        const png = decodePng(await readFile9(output.absolutePath));
+        const png = decodePng(await readFile10(output.absolutePath));
         const palette = extractPalette(png, 12);
         assets.push({
           assetId: spec.assetId,
@@ -3615,10 +3863,10 @@ async function auditStyle(loaded, specs, styleId, lock) {
   let referenceFromStyleImages = false;
   const refPalettes = [];
   for (const img of style.styleImages) {
-    const abs = path12.resolve(loaded.root, img.path);
-    if (!existsSync12(abs)) continue;
+    const abs = path14.resolve(loaded.root, img.path);
+    if (!existsSync13(abs)) continue;
     try {
-      refPalettes.push(extractPalette(decodePng(await readFile9(abs)), 12));
+      refPalettes.push(extractPalette(decodePng(await readFile10(abs)), 12));
     } catch {
     }
   }
@@ -3694,16 +3942,16 @@ function hex(c) {
 }
 
 // src/pipeline/cache-health.ts
-import { existsSync as existsSync13 } from "fs";
-import { readFile as readFile10, readdir as readdir2, rm as rm4 } from "fs/promises";
-import path13 from "path";
+import { existsSync as existsSync14 } from "fs";
+import { readFile as readFile11, readdir as readdir2, rm as rm5 } from "fs/promises";
+import path15 from "path";
 var PNG_SIGNATURE2 = Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]);
 async function inspectCaches(lock, lockPath, options = {}) {
-  if (options.prune && !existsSync13(lockPath)) {
-    throw new Error(`Refusing to prune without an existing lockfile at ${path13.resolve(lockPath)}`);
+  if (options.prune && !existsSync14(lockPath)) {
+    throw new Error(`Refusing to prune without an existing lockfile at ${path15.resolve(lockPath)}`);
   }
-  const contentDir = path13.resolve(path13.dirname(lockPath), ".pixelkiln", "cache");
-  const remotePath = path13.resolve(cachePathFor(lockPath));
+  const contentDir = path15.resolve(path15.dirname(lockPath), ".pixelkiln", "cache");
+  const remotePath = path15.resolve(cachePathFor(lockPath));
   const referenced = new Set(
     Object.values(lock.entries).flatMap((entry) => entry.outputs.map((output) => output.sha256))
   );
@@ -3717,7 +3965,7 @@ async function inspectCaches(lock, lockPath, options = {}) {
     ]);
     for (const name of names) {
       try {
-        await rm4(path13.join(contentDir, name), { force: true });
+        await rm5(path15.join(contentDir, name), { force: true });
         removed.contentFiles++;
       } catch {
       }
@@ -3726,7 +3974,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 readFile10(remotePath, "utf8")));
+      const cache = parseCache(JSON.parse(await readFile11(remotePath, "utf8")));
       for (const id of remoteHashes.invalidIds) delete cache.hashes[id];
       removed.remoteHashEntries = remoteHashes.invalidIds.length;
       await saveCache(remotePath, cache);
@@ -3744,7 +3992,7 @@ async function inspectCaches(lock, lockPath, options = {}) {
 async function inspectContentCache(contentDir, referenced) {
   const report = {
     path: contentDir,
-    exists: existsSync13(contentDir),
+    exists: existsSync14(contentDir),
     files: 0,
     bytes: 0,
     valid: 0,
@@ -3765,11 +4013,11 @@ async function inspectContentCache(contentDir, referenced) {
       continue;
     }
     report.files++;
-    const file = path13.join(contentDir, entry.name);
+    const file = path15.join(contentDir, entry.name);
     const expected = entry.name.endsWith(".png") ? entry.name.slice(0, -4) : "";
     let bytes;
     try {
-      bytes = await readFile10(file);
+      bytes = await readFile11(file);
       report.bytes += bytes.length;
     } catch (err) {
       report.invalid.push({
@@ -3811,7 +4059,7 @@ async function inspectContentCache(contentDir, referenced) {
 async function inspectRemoteHashCache(remotePath) {
   const report = {
     path: remotePath,
-    exists: existsSync13(remotePath),
+    exists: existsSync14(remotePath),
     entries: 0,
     valid: 0,
     invalidIds: [],
@@ -3820,7 +4068,7 @@ async function inspectRemoteHashCache(remotePath) {
   if (!report.exists) return report;
   let cache;
   try {
-    cache = parseCache(JSON.parse(await readFile10(remotePath, "utf8")));
+    cache = parseCache(JSON.parse(await readFile11(remotePath, "utf8")));
   } catch (err) {
     report.error = err instanceof Error ? err.message : String(err);
     return report;
@@ -4091,8 +4339,8 @@ function isRecord(value) {
 }
 
 // src/pick/salvage-server.ts
-import { mkdir as mkdir4, writeFile as writeFile6, readFile as readFile11 } from "fs/promises";
-import path14 from "path";
+import { mkdir as mkdir5, writeFile as writeFile7, readFile as readFile12 } from "fs/promises";
+import path16 from "path";
 
 // src/pick/salvage-sheet.ts
 var escapeHtml2 = (s) => s.replace(/[&<>"']/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" })[c]);
@@ -4257,7 +4505,7 @@ async function runSalvage(provider, orphans, ctx, opts = {}) {
   });
   const html = renderSalvageSheet(orphans, {
     styleId: ctx.styleId,
-    importDir: path14.relative(process.cwd(), ctx.importDir) || "."
+    importDir: path16.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]));
@@ -4286,10 +4534,10 @@ async function runSalvage(provider, orphans, ctx, opts = {}) {
             if (!buf.subarray(0, 8).equals(PNG_SIGNATURE3)) throw new Error("not a PNG");
             decodePng(buf);
             const assetId = idFromPrompt(orphan.prompt, taken);
-            const rel = path14.join("_salvaged", `${assetId}.png`);
-            const outFile = path14.resolve(ctx.importDir, rel);
-            await mkdir4(path14.dirname(outFile), { recursive: true });
-            await writeFile6(outFile, buf);
+            const rel = path16.join("_salvaged", `${assetId}.png`);
+            const outFile = path16.resolve(ctx.importDir, rel);
+            await mkdir5(path16.dirname(outFile), { recursive: true });
+            await writeFile7(outFile, buf);
             ctx.manifest.assets[assetId] = {
               prompt: orphan.prompt,
               promptByStyle: {},
@@ -4315,7 +4563,7 @@ async function runSalvage(provider, orphans, ctx, opts = {}) {
               error: null,
               sourceUrl: orphan.previewUrl,
               outputs: [{
-                path: portableOutputPath(outFile, path14.dirname(ctx.manifestPath)),
+                path: portableOutputPath(outFile, path16.dirname(ctx.manifestPath)),
                 sha256: sha256(buf)
               }],
               submittedAt: orphan.createdAt,
@@ -4339,9 +4587,9 @@ async function runSalvage(provider, orphans, ctx, opts = {}) {
         }
       }
       await applyTags(provider, decisions, existingTags, { onProgress: log2 });
-      const raw = JSON.parse(await readFile11(ctx.manifestPath, "utf8"));
+      const raw = JSON.parse(await readFile12(ctx.manifestPath, "utf8"));
       for (const id of importedAssetIds) raw.assets[id] = ctx.manifest.assets[id];
-      await writeFile6(ctx.manifestPath, JSON.stringify(raw, null, 2) + "\n");
+      await writeFile7(ctx.manifestPath, JSON.stringify(raw, null, 2) + "\n");
       await saveLock(ctx.lockPath, ctx.lock);
       return result;
     }
@@ -4349,9 +4597,9 @@ async function runSalvage(provider, orphans, ctx, opts = {}) {
 }
 
 // src/artifacts.ts
-import path15 from "path";
+import path17 from "path";
 import { createHash as createHash2, randomUUID as randomUUID2 } from "crypto";
-import { mkdir as mkdir5, readFile as readFile12, rename as rename4, rm as rm5, writeFile as writeFile7 } from "fs/promises";
+import { mkdir as mkdir6, readFile as readFile13, rename as rename5, rm as rm6, writeFile as writeFile8 } from "fs/promises";
 var activeTransactions = /* @__PURE__ */ new Set();
 function message(error) {
   return error instanceof Error ? error.message : String(error);
@@ -4360,7 +4608,7 @@ function digest(data) {
   return createHash2("sha256").update(data).digest("hex");
 }
 function portableRelative(from, to) {
-  return path15.relative(from, path15.resolve(to)).split(path15.sep).join("/") || ".";
+  return path17.relative(from, path17.resolve(to)).split(path17.sep).join("/") || ".";
 }
 function canonical(value) {
   if (value === null || typeof value === "string" || typeof value === "boolean") return value;
@@ -4411,7 +4659,7 @@ function parseArtifactManifest(absolute, data) {
 }
 async function readOptional(file) {
   try {
-    return await readFile12(file);
+    return await readFile13(file);
   } catch (error) {
     if (isCode(error, "ENOENT")) return null;
     throw error;
@@ -4430,8 +4678,8 @@ function processIsAlive(pid) {
   }
 }
 function validTemporaryPath(candidate, destination, type) {
-  return path15.dirname(candidate) === path15.dirname(destination) && path15.basename(candidate).startsWith(
-    `.${path15.basename(destination)}.pixelkiln-${type}-`
+  return path17.dirname(candidate) === path17.dirname(destination) && path17.basename(candidate).startsWith(
+    `.${path17.basename(destination)}.pixelkiln-${type}-`
   );
 }
 function parseTransaction(journal, data) {
@@ -4447,14 +4695,14 @@ function parseTransaction(journal, data) {
   return raw;
 }
 async function removeTransactionFiles(journal) {
-  await rm5(journal, { force: true });
-  await rm5(transactionMarker(journal), { force: true });
+  await rm6(journal, { force: true });
+  await rm6(transactionMarker(journal), { force: true });
 }
 async function recoverArtifactTransaction(recoveryFile, allowedDestinations) {
-  const journal = path15.resolve(recoveryFile);
+  const journal = path17.resolve(recoveryFile);
   const bytes = await readOptional(journal);
   if (!bytes) {
-    await rm5(transactionMarker(journal), { force: true });
+    await rm6(transactionMarker(journal), { force: true });
     return;
   }
   if (activeTransactions.has(journal)) {
@@ -4467,7 +4715,7 @@ async function recoverArtifactTransaction(recoveryFile, allowedDestinations) {
     );
   }
   for (const entry of transaction.entries) {
-    if (typeof entry.destination !== "string" || typeof entry.stage !== "string" || typeof entry.sha256 !== "string" || entry.backup !== void 0 && typeof entry.backup !== "string" || !allowedDestinations.has(path15.resolve(entry.destination)) || !validTemporaryPath(entry.stage, entry.destination, "stage") || entry.backup !== void 0 && !validTemporaryPath(entry.backup, entry.destination, "backup")) {
+    if (typeof entry.destination !== "string" || typeof entry.stage !== "string" || typeof entry.sha256 !== "string" || entry.backup !== void 0 && typeof entry.backup !== "string" || !allowedDestinations.has(path17.resolve(entry.destination)) || !validTemporaryPath(entry.stage, entry.destination, "stage") || entry.backup !== void 0 && !validTemporaryPath(entry.backup, entry.destination, "backup")) {
       throw new Error(
         `Refusing unsafe artifact recovery from ${journal}; its destinations or temporary paths do not match the current bundle.`
       );
@@ -4493,7 +4741,7 @@ async function recoverArtifactTransaction(recoveryFile, allowedDestinations) {
         }
         await remove2(entry.destination, errors);
         try {
-          await rename4(entry.backup, entry.destination);
+          await rename5(entry.backup, entry.destination);
         } catch (error) {
           errors.push(
             `could not restore ${entry.destination}; previous file remains at ${entry.backup}: ${message(error)}`
@@ -4513,7 +4761,7 @@ async function recoverArtifactTransaction(recoveryFile, allowedDestinations) {
   await removeTransactionFiles(journal);
 }
 function createArtifactBundleManifest(manifestPath, outputs, provenance) {
-  const root = path15.dirname(path15.resolve(manifestPath));
+  const root = path17.dirname(path17.resolve(manifestPath));
   const sources = provenance.sources.map((source) => ({
     ...source,
     path: portableRelative(root, source.path)
@@ -4543,11 +4791,11 @@ function withArtifactManifest(manifestPath, outputs, provenance) {
   ];
 }
 async function writeManagedArtifactBundle(manifestPath, outputs, provenance, options = {}) {
-  const absoluteManifest = path15.resolve(manifestPath);
+  const absoluteManifest = path17.resolve(manifestPath);
   const recoveryFile = `${absoluteManifest}.transaction`;
   const allowedDestinations = /* @__PURE__ */ new Set([
     absoluteManifest,
-    ...outputs.map((output) => path15.resolve(output.path))
+    ...outputs.map((output) => path17.resolve(output.path))
   ]);
   await recoverArtifactTransaction(recoveryFile, allowedDestinations);
   const existingManifestBytes = await readOptional(absoluteManifest);
@@ -4565,13 +4813,13 @@ async function writeManagedArtifactBundle(manifestPath, outputs, provenance, opt
     }
   }
   if (!options.force) {
-    const root = path15.dirname(absoluteManifest);
+    const root = path17.dirname(absoluteManifest);
     const recorded = new Map(
-      previous?.outputs.map((output) => [path15.resolve(root, output.path), output.sha256]) ?? []
+      previous?.outputs.map((output) => [path17.resolve(root, output.path), output.sha256]) ?? []
     );
     const conflicts = [];
     for (const output of outputs) {
-      const destination = path15.resolve(output.path);
+      const destination = path17.resolve(output.path);
       const current = await readOptional(destination);
       if (!current || digest(current) === digest(output.data)) continue;
       const expected = recorded.get(destination);
@@ -4596,7 +4844,7 @@ function isCode(error, code) {
 }
 async function remove2(file, errors) {
   try {
-    await rm5(file, { force: true });
+    await rm6(file, { force: true });
   } catch (error) {
     errors?.push(`could not remove ${file}: ${message(error)}`);
   }
@@ -4609,7 +4857,7 @@ async function rollback(prepared) {
   for (const artifact of [...prepared].reverse()) {
     if (!artifact.backup || !artifact.backedUp) continue;
     try {
-      await rename4(artifact.backup, artifact.destination);
+      await rename5(artifact.backup, artifact.destination);
       artifact.backedUp = false;
     } catch (error) {
       errors.push(
@@ -4626,7 +4874,7 @@ async function writeArtifactBundle(files, options = {}) {
   if (!files.length) throw new Error("An artifact bundle must contain at least one file.");
   const normalized = files.map((file) => {
     if (!file.path.trim()) throw new Error("Artifact paths cannot be empty.");
-    return { destination: path15.resolve(file.path), data: Buffer.from(file.data) };
+    return { destination: path17.resolve(file.path), data: Buffer.from(file.data) };
   });
   const destinations = /* @__PURE__ */ new Set();
   for (const artifact of normalized) {
@@ -4642,7 +4890,7 @@ async function writeArtifactBundle(files, options = {}) {
   const unchanged = [];
   for (const artifact of normalized) {
     try {
-      const current = await readFile12(artifact.destination);
+      const current = await readFile13(artifact.destination);
       if (current.equals(artifact.data)) {
         unchanged.push(artifact.destination);
       } else {
@@ -4656,21 +4904,21 @@ async function writeArtifactBundle(files, options = {}) {
   if (!changed.length) return { changed: [], unchanged };
   const token = randomUUID2();
   for (const [index, artifact] of changed.entries()) {
-    const basename = path15.basename(artifact.destination);
-    artifact.stage = path15.join(
-      path15.dirname(artifact.destination),
+    const basename = path17.basename(artifact.destination);
+    artifact.stage = path17.join(
+      path17.dirname(artifact.destination),
       `.${basename}.pixelkiln-stage-${token}-${index}`
     );
     if (artifact.existed) {
-      artifact.backup = path15.join(
-        path15.dirname(artifact.destination),
+      artifact.backup = path17.join(
+        path17.dirname(artifact.destination),
         `.${basename}.pixelkiln-backup-${token}-${index}`
       );
     }
   }
-  const journal = options.recoveryFile ? path15.resolve(options.recoveryFile) : null;
+  const journal = options.recoveryFile ? path17.resolve(options.recoveryFile) : null;
   if (journal) {
-    await mkdir5(path15.dirname(journal), { recursive: true });
+    await mkdir6(path17.dirname(journal), { recursive: true });
     const transaction = {
       format: "pixelkiln-artifact-transaction",
       version: 1,
@@ -4684,7 +4932,7 @@ async function writeArtifactBundle(files, options = {}) {
       }))
     };
     try {
-      await writeFile7(journal, JSON.stringify(transaction, null, 2) + "\n", { flag: "wx" });
+      await writeFile8(journal, JSON.stringify(transaction, null, 2) + "\n", { flag: "wx" });
       activeTransactions.add(journal);
     } catch (error) {
       throw new Error(
@@ -4695,9 +4943,9 @@ async function writeArtifactBundle(files, options = {}) {
   }
   try {
     for (const [index, artifact] of changed.entries()) {
-      await mkdir5(path15.dirname(artifact.destination), { recursive: true });
+      await mkdir6(path17.dirname(artifact.destination), { recursive: true });
       await options.beforeStage?.(artifact.destination, index);
-      await writeFile7(artifact.stage, artifact.data, { flag: "wx" });
+      await writeFile8(artifact.stage, artifact.data, { flag: "wx" });
     }
   } catch (error) {
     const cleanupErrors2 = await rollback(changed);
@@ -4710,17 +4958,17 @@ async function writeArtifactBundle(files, options = {}) {
   try {
     for (const artifact of changed) {
       if (!artifact.existed) continue;
-      await rename4(artifact.destination, artifact.backup);
+      await rename5(artifact.destination, artifact.backup);
       artifact.backedUp = true;
     }
     for (const [index, artifact] of changed.entries()) {
       await options.beforePromote?.(artifact.destination, index);
-      await rename4(artifact.stage, artifact.destination);
+      await rename5(artifact.stage, artifact.destination);
       artifact.stage = void 0;
       artifact.promoted = true;
     }
     if (journal) {
-      await writeFile7(transactionMarker(journal), `${token}
+      await writeFile8(transactionMarker(journal), `${token}
 `, { flag: "wx" });
       durableCommit = true;
       await options.afterCommit?.();
@@ -4765,11 +5013,11 @@ async function writeArtifactBundle(files, options = {}) {
 // src/cli.ts
 var log = (msg = "") => console.log(msg);
 async function provenanceFile(id, file) {
-  const absolute = path16.resolve(file);
+  const absolute = path18.resolve(file);
   return {
     id,
     path: absolute,
-    sha256: existsSync14(absolute) ? await sha256File(absolute) : null,
+    sha256: existsSync15(absolute) ? await sha256File(absolute) : null,
     included: true
   };
 }
@@ -4793,7 +5041,10 @@ var VALUE_FLAGS = [
   "--max-distance",
   "--min-transparency",
   "--max-colors",
-  "--sigma"
+  "--sigma",
+  "--workspace",
+  "--provider",
+  "--account"
 ];
 var BOOL_FLAGS = [
   "--force",
@@ -4832,18 +5083,43 @@ var COMMANDS = [
   "tag",
   "balance",
   "status",
+  "workspace",
   "help",
   "--help",
   "-h",
   "--version",
   "-v"
 ];
+var WORKSPACE_SUBCOMMANDS = ["add", "remove", "list", "status", "claims"];
 function parseArgs(argv) {
   const [command = "help"] = argv;
   if (!COMMANDS.includes(command)) {
     throw new Error(`Unknown command "${command}". Run \`pixelkiln help\` for the list.`);
   }
-  const rest = argv.slice(1);
+  let rest = argv.slice(1);
+  let subcommand;
+  let target;
+  if (command === "workspace") {
+    subcommand = rest[0];
+    if (subcommand === void 0 || subcommand.startsWith("-")) {
+      throw new Error(`workspace needs a subcommand: ${WORKSPACE_SUBCOMMANDS.join(", ")}`);
+    }
+    if (!WORKSPACE_SUBCOMMANDS.includes(subcommand)) {
+      throw new Error(
+        `Unknown workspace subcommand "${subcommand}". Known: ${WORKSPACE_SUBCOMMANDS.join(", ")}`
+      );
+    }
+    rest = rest.slice(1);
+    if (subcommand === "add" || subcommand === "remove") {
+      target = rest[0];
+      if (target === void 0 || target.startsWith("-")) {
+        throw new Error(
+          subcommand === "add" ? "workspace add needs a manifest path." : "workspace remove needs a project id or manifest path."
+        );
+      }
+      rest = rest.slice(1);
+    }
+  }
   for (let i = 0; i < rest.length; i++) {
     const token = rest[i];
     if (!token.startsWith("-")) {
@@ -4920,7 +5196,8 @@ function parseArgs(argv) {
   return {
     command,
     manifest,
-    lock: get("--lock") ?? path16.join(path16.dirname(path16.resolve(manifest)), "pixelkiln.lock.json"),
+    lock: get("--lock") ?? path18.join(path18.dirname(path18.resolve(manifest)), "pixelkiln.lock.json"),
+    explicitLock: get("--lock"),
     styles: list("--style"),
     assets: list("--only"),
     force: rest.includes("--force"),
@@ -4949,7 +5226,12 @@ function parseArgs(argv) {
     maxDistance: numberOption("--max-distance", { min: 0 }),
     minTransparency: numberOption("--min-transparency", { min: 0, max: 1 }),
     maxColors: numberOption("--max-colors", { min: 1, integer: true }),
-    sigma: numberOption("--sigma", { min: Number.EPSILON })
+    sigma: numberOption("--sigma", { min: Number.EPSILON }),
+    subcommand,
+    workspace: get("--workspace"),
+    target,
+    provider: get("--provider"),
+    account: get("--account")
   };
 }
 var HELP = `pixelkiln \u2014 manifest-driven pixel art generation (PixelLab)
@@ -4982,6 +5264,8 @@ Commands
   tag       Push manifest tags to the objects upstream (free).
   balance   Show the provider's remaining balance.
   status    Summarise the lockfile.
+  workspace Register sibling projects and derive account-wide claims/status.
+            add/remove/list/status/claims. Offline.
 
 Options
   --columns <n>       pack/export: sprites or tiles per row (default: near-square)
@@ -5009,6 +5293,8 @@ Options
   --no-open           Do not auto-open the browser during pick
   --tag               Also push tags upstream after fetch
   --claims a.json,b   Other projects' lockfiles (salvage; required if account is shared)
+  --workspace <path>  Workspace catalog (default: pixelkiln.workspace.json). Also
+                       derives salvage's claim set instead of repeated --claims.
   --from <dir>        Source tree for init
   --write-prompts     adopt: recover prompts into the manifest
 
@@ -5021,6 +5307,9 @@ Examples
   pixelkiln pack --inputs sprites.json --out dist/sheet   # no manifest needed
   pixelkiln mount --style ground
   pixelkiln export --style ground --only terrain --format tiled
+  pixelkiln workspace add ../other-game/pixelkiln.manifest.json
+  pixelkiln workspace status --json
+  pixelkiln salvage --workspace pixelkiln.workspace.json
 `;
 function printPlan(plan) {
   const counts = summarize(plan);
@@ -5061,6 +5350,23 @@ async function confirm(question, auto) {
   process.stdin.pause();
   return answer === "y" || answer === "yes";
 }
+async function requireCompleteWorkspaceClaims(workspacePath) {
+  if (!existsSync15(workspacePath)) {
+    throw new Error(`Workspace catalog not found: ${workspacePath}`);
+  }
+  const dir = path18.dirname(path18.resolve(workspacePath));
+  const ws = await loadWorkspace(workspacePath);
+  const diagnostics = validateWorkspace(ws, dir);
+  const errors = diagnostics.filter((d) => d.level === "error");
+  if (errors.length) {
+    throw new Error(
+      `Workspace catalog at ${workspacePath} is not safe to derive a claim set from:
+` + errors.map((d) => `  ${d.id}: ${d.message}`).join("\n")
+    );
+  }
+  const claims = await workspaceClaims(ws, dir);
+  return { ws, dir, diagnostics, claims };
+}
 async function main() {
   const args = parseArgs(process.argv.slice(2));
   if (args.command === "help" || args.command === "--help" || args.command === "-h") {
@@ -5069,13 +5375,13 @@ async function main() {
   }
   if (args.command === "--version" || args.command === "-v") {
     const pkg = JSON.parse(
-      await readFile13(new URL("../package.json", import.meta.url), "utf8")
+      await readFile14(new URL("../package.json", import.meta.url), "utf8")
     );
     log(`${pkg.name} ${pkg.version}`);
     return;
   }
   if (args.command === "balance") {
-    loadEnvFiles(path16.dirname(path16.resolve(args.manifest)));
+    loadEnvFiles(path18.dirname(path18.resolve(args.manifest)));
     loadEnvFiles(process.cwd());
     const p = PixelLabProvider.fromEnv();
     const b = await p.balance();
@@ -5086,31 +5392,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 = path16.resolve(args.from);
-    if (!existsSync14(root)) throw new Error(`No directory at ${root}`);
+    const root = path18.resolve(args.from);
+    if (!existsSync15(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 = path16.resolve(args.out ?? "pixelkiln.manifest.json");
+    const target = path18.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 ?? path16.basename(path16.dirname(target)),
+      args.name ?? path18.basename(path18.dirname(target)),
       args.styles[0] ?? "base",
       generator,
-      path16.relative(path16.dirname(target), root) || ".",
+      path18.relative(path18.dirname(target), root) || ".",
       assets
     );
     await writeManifestFile(target, manifest);
-    log(`  scanned ${assets.length} PNG(s) under ${path16.relative(process.cwd(), root)}`);
+    log(`  scanned ${assets.length} PNG(s) under ${path18.relative(process.cwd(), root)}`);
     if (skipped.length) log(`  skipped ${skipped.length} unreadable file(s)`);
-    log(`  wrote ${path16.relative(process.cwd(), target)}`);
+    log(`  wrote ${path18.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 ${path16.relative(process.cwd(), target)} --write-prompts
+    pixelkiln adopt --manifest ${path18.relative(process.cwd(), target)} --write-prompts
 `);
     return;
   }
@@ -5158,10 +5464,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 readFile13(path16.resolve(args.inputs), "utf8"));
+    const raw = JSON.parse(await readFile14(path18.resolve(args.inputs), "utf8"));
     const inputs = resolvePackInputs(raw, args.inputs);
     const { png, atlas, skipped, sources } = packSprites(inputs, { columns: args.columns });
-    const base = path16.resolve(args.out.replace(/\.png$/, ""));
+    const base = path18.resolve(args.out.replace(/\.png$/, ""));
     const outputs = [
       { path: `${base}.png`, data: png },
       { path: `${base}.json`, data: JSON.stringify(atlas, null, 2) + "\n" }
@@ -5174,18 +5480,143 @@ 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(`    ${path16.relative(process.cwd(), base)}.png + .json + .pixelkiln.json`);
+    log(`    ${path18.relative(process.cwd(), base)}.png + .json + .pixelkiln.json`);
     for (const s of skipped) log(`    skipped ${s.id}: ${s.reason}`);
     return;
   }
-  if (!existsSync14(path16.resolve(args.manifest))) {
+  if (args.command === "workspace") {
+    const workspacePath = path18.resolve(args.workspace ?? "pixelkiln.workspace.json");
+    const dir = path18.dirname(workspacePath);
+    if (args.subcommand === "add") {
+      const manifestPath = path18.resolve(args.target);
+      const loadedTarget = await loadManifest(manifestPath);
+      const lockPath = args.explicitLock ? path18.resolve(args.explicitLock) : path18.join(path18.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)) {
+        throw new Error(
+          `Project id "${id}" is already registered in ${workspacePath}. Pass --name for a different id.`
+        );
+      }
+      const lockOwner = ws.projects.find((p) => resolveProject(dir, p).lockPath === lockPath);
+      if (lockOwner) {
+        throw new Error(`Lockfile ${lockPath} is already registered under project id "${lockOwner.id}".`);
+      }
+      const project = {
+        id,
+        manifest: toPortablePath(dir, manifestPath),
+        lock: toPortablePath(dir, lockPath),
+        provider: args.provider ?? "pixellab",
+        ...args.account ? { account: args.account } : {}
+      };
+      await saveWorkspace(workspacePath, { version: 1, projects: [...ws.projects, project] });
+      log(`  registered "${id}" in ${path18.relative(process.cwd(), workspacePath)}`);
+      log(`    manifest: ${project.manifest}`);
+      log(`    lock:     ${project.lock}`);
+      if (!existsSync15(lockPath)) {
+        log(
+          `  warning: no lockfile there yet \u2014 this project contributes no claims until one is generated`
+        );
+      }
+      return;
+    }
+    if (args.subcommand === "remove") {
+      const ws = await loadWorkspace(workspacePath);
+      const resolvedTarget = path18.resolve(args.target);
+      const match = ws.projects.find(
+        (p) => p.id === args.target || resolveProject(dir, p).manifestPath === resolvedTarget
+      );
+      if (!match) {
+        throw new Error(`No registered project matches "${args.target}" (checked id and manifest path).`);
+      }
+      await saveWorkspace(workspacePath, {
+        version: 1,
+        projects: ws.projects.filter((p) => p !== match)
+      });
+      log(`  removed "${match.id}" from ${path18.relative(process.cwd(), workspacePath)}`);
+      return;
+    }
+    if (args.subcommand === "list") {
+      if (!existsSync15(workspacePath)) {
+        throw new Error(`Workspace catalog not found: ${workspacePath}`);
+      }
+      const ws = await loadWorkspace(workspacePath);
+      const diagnostics = validateWorkspace(ws, dir);
+      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 ${path18.relative(process.cwd(), workspacePath)}`);
+      } else {
+        log(`  ${ws.projects.length} project(s) in ${path18.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}` : ""})`);
+        }
+        for (const d of diagnostics) log(`  ${d.level === "error" ? "ERROR" : "WARN "} ${d.id.padEnd(18)} ${d.message}`);
+      }
+      if (args.check && diagnostics.some((d) => d.level === "error")) process.exitCode = 1;
+      return;
+    }
+    if (args.subcommand === "status") {
+      if (!existsSync15(workspacePath)) {
+        throw new Error(`Workspace catalog not found: ${workspacePath}`);
+      }
+      const ws = await loadWorkspace(workspacePath);
+      const report = await workspaceStatus(ws, dir);
+      if (args.json) {
+        log(JSON.stringify({ ...report, workspace: workspacePath }, null, 2));
+      } else {
+        log(`  workspace: ${path18.relative(process.cwd(), workspacePath)}`);
+        for (const p of report.projects) {
+          if (p.error) {
+            log(`
+  ${p.id} \u2014 ERROR: ${p.error}`);
+            continue;
+          }
+          log(`
+  ${p.id}  (${p.provider}${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 of ["generations", "usd", "free"]) {
+            if (p.spendByUnit[unit]) log(`    spend: ${formatCost(unit, p.spendByUnit[unit])}`);
+          }
+        }
+        log(`
+  totals:`);
+        for (const [state, n] of Object.entries(report.totals.byState)) if (n) log(`    ${state.padEnd(12)} ${n}`);
+        for (const unit of ["generations", "usd", "free"]) {
+          if (report.totals.spendByUnit[unit]) log(`    spend: ${formatCost(unit, report.totals.spendByUnit[unit])}`);
+        }
+        log(`    claims: ${report.totals.claims}`);
+        for (const d of report.diagnostics) log(`  ${d.level === "error" ? "ERROR" : "WARN "} ${d.id.padEnd(18)} ${d.message}`);
+      }
+      if (args.check && !report.safe) process.exitCode = 1;
+      return;
+    }
+    if (args.subcommand === "claims") {
+      const { claims, diagnostics } = await requireCompleteWorkspaceClaims(workspacePath);
+      if (args.json) {
+        log(JSON.stringify({
+          version: 1,
+          claimed: [...claims.claimed].sort(),
+          byProject: claims.byProject,
+          lockPaths: claims.lockPaths
+        }, null, 2));
+      } else {
+        log(`  ${claims.claimed.size} claimed id(s) across ${claims.lockPaths.length} lockfile(s):`);
+        for (const [id, n] of Object.entries(claims.byProject).sort()) log(`    ${id.padEnd(24)} ${n}`);
+        for (const d of diagnostics) log(`  WARN  ${d.id.padEnd(18)} ${d.message}`);
+      }
+      return;
+    }
+  }
+  if (!existsSync15(path18.resolve(args.manifest))) {
     throw new Error(
-      `No manifest at ${path16.resolve(args.manifest)}. Pass --manifest, or run \`pixelkiln init --from <dir>\`.`
+      `No manifest at ${path18.resolve(args.manifest)}. Pass --manifest, or run \`pixelkiln init --from <dir>\`.`
     );
   }
-  const manifestDir = path16.dirname(path16.resolve(args.manifest));
+  const manifestDir = path18.dirname(path18.resolve(args.manifest));
   const envFiles = [...loadEnvFiles(manifestDir)];
-  if (path16.resolve(process.cwd()) !== manifestDir) envFiles.push(...loadEnvFiles(process.cwd()));
+  if (path18.resolve(process.cwd()) !== manifestDir) envFiles.push(...loadEnvFiles(process.cwd()));
   const loaded = await loadManifest(args.manifest);
   const estimator = PixelLabProvider.forOffline();
   const specs = await resolveSpecs(loaded, {
@@ -5260,7 +5691,7 @@ async function main() {
       let intact = true;
       for (const output of entry.outputs) {
         const file = resolveOutputPath(output.path, item.spec.root);
-        if (!existsSync14(file) || await sha256File(file) !== output.sha256) {
+        if (!existsSync15(file) || await sha256File(file) !== output.sha256) {
           intact = false;
           break;
         }
@@ -5318,7 +5749,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 = path16.dirname(path16.resolve(args.manifest));
+    const manifestDir2 = path18.dirname(path18.resolve(args.manifest));
     const styleIds = args.styles.length ? args.styles : Object.keys(loaded.manifest.styles);
     for (const styleId of styleIds) {
       const { png, atlas, skipped, sources } = packStyle(lock, styleId, manifestDir2, {
@@ -5327,7 +5758,7 @@ async function main() {
         primaryOnly: args.primaryOnly
       });
       const style = loaded.manifest.styles[styleId];
-      const base = args.out ? path16.resolve(args.out.replace(/\.png$/, "")) : path16.resolve(manifestDir2, style.outDir, `${styleId}-sheet`);
+      const base = args.out ? path18.resolve(args.out.replace(/\.png$/, "")) : path18.resolve(manifestDir2, style.outDir, `${styleId}-sheet`);
       const outputs = [
         { path: `${base}.png`, data: png },
         { path: `${base}.json`, data: JSON.stringify(atlas, null, 2) + "\n" }
@@ -5350,13 +5781,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(`    ${path16.relative(process.cwd(), base)}.png + .json + .pixelkiln.json`);
+      log(`    ${path18.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 = path16.dirname(path16.resolve(args.manifest));
+    const manifestDir2 = path18.dirname(path18.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];
@@ -5386,7 +5817,7 @@ async function main() {
         sources,
         outputRoles
       );
-      const out = path16.resolve(manifestDir2, style.mount.out);
+      const out = path18.resolve(manifestDir2, style.mount.out);
       const metadata = out.replace(/\.png$/, "") + ".json";
       const companion = out.replace(/\.png$/, "") + ".pixelkiln.json";
       const outputs = [
@@ -5399,7 +5830,7 @@ async function main() {
           await provenanceFile("$manifest", args.manifest),
           await provenanceFile("$lock", args.lock),
           ...artifactSources.filter(
-            (source) => source.id !== "$base" || path16.resolve(source.path) !== out
+            (source) => source.id !== "$base" || path18.resolve(source.path) !== out
           )
         ],
         options: {
@@ -5412,7 +5843,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(`    ${path16.relative(process.cwd(), out)} + atlas/provenance JSON`);
+      log(`    ${path18.relative(process.cwd(), out)} + atlas/provenance JSON`);
       for (const s of skipped) log(`    skipped ${s.id}: ${s.reason}`);
     }
     return;
@@ -5468,7 +5899,7 @@ async function main() {
   }
   if (args.command === "export") {
     const format = args.format ?? "generic";
-    const manifestDir2 = path16.dirname(path16.resolve(args.manifest));
+    const manifestDir2 = path18.dirname(path18.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;
@@ -5484,12 +5915,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 = path16.resolve(manifestDir2, style.outDir, `${spec.assetId}-tileset`);
-      const base = args.out ? path16.resolve(args.out.replace(/\.(?:png|json|tsj|tres)$/i, "")) : defaultBase;
+      const defaultBase = path18.resolve(manifestDir2, style.outDir, `${spec.assetId}-tileset`);
+      const base = args.out ? path18.resolve(args.out.replace(/\.(?:png|json|tsj|tres)$/i, "")) : defaultBase;
       const result = exportTileset(entry, spec, {
         format,
         manifestDir: manifestDir2,
-        imageName: path16.basename(`${base}.png`),
+        imageName: path18.basename(`${base}.png`),
         columns: args.columns
       });
       const outputs = [
@@ -5507,7 +5938,7 @@ async function main() {
           asset: spec.assetId,
           columns: args.columns ?? null,
           format,
-          image: path16.basename(`${base}.png`),
+          image: path18.basename(`${base}.png`),
           providerRules: result.generic.providerRules,
           style: spec.styleId,
           tileType: spec.tileType ?? null
@@ -5517,7 +5948,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(
-        `    ${path16.relative(process.cwd(), base)}.png + ${path16.basename(base)}${result.extension} + .pixelkiln.json`
+        `    ${path18.relative(process.cwd(), base)}.png + ${path18.basename(base)}${result.extension} + .pixelkiln.json`
       );
     }
     return;
@@ -5557,10 +5988,10 @@ async function main() {
   tagged ${n} object(s) upstream`);
     }
     if (args.writePrompts) {
-      const { filled, stillEmpty } = await writePromptsBack(path16.resolve(args.manifest), lock, {
+      const { filled, stillEmpty } = await writePromptsBack(path18.resolve(args.manifest), lock, {
         onProgress: log
       });
-      log(`  recovered ${filled} prompt(s) into ${path16.relative(process.cwd(), args.manifest)}`);
+      log(`  recovered ${filled} prompt(s) into ${path18.relative(process.cwd(), args.manifest)}`);
       const reloaded = await loadManifest(args.manifest);
       const rebased = await resolveSpecs(reloaded, {
         styles: args.styles,
@@ -5589,19 +6020,39 @@ async function main() {
   if (args.command === "salvage") {
     const jsonMode = args.dryRun && args.json;
     const diag = jsonMode ? (msg = "") => console.error(msg) : log;
-    const ownLock = path16.resolve(args.lock);
+    const ownLock = path18.resolve(args.lock);
+    let workspaceProjects = [];
+    let workspaceDir = "";
+    if (args.workspace) {
+      const workspacePath = path18.resolve(args.workspace);
+      workspaceDir = path18.dirname(workspacePath);
+      const complete = await requireCompleteWorkspaceClaims(workspacePath);
+      workspaceProjects = complete.ws.projects;
+      for (const d of complete.diagnostics) diag(`  WARN  ${d.id}: ${d.message}`);
+    }
+    const workspaceLockPaths = workspaceProjects.map((p) => resolveProject(workspaceDir, p).lockPath);
     const lockPaths = [
-      ...existsSync14(ownLock) ? [ownLock] : [],
-      ...args.claims.map((c) => path16.resolve(c))
+      .../* @__PURE__ */ new Set([
+        ...workspaceLockPaths,
+        ...existsSync15(ownLock) ? [ownLock] : [],
+        ...args.claims.map((c) => path18.resolve(c))
+      ])
     ];
     diag(`  claim set (${lockPaths.length} lockfile(s)):`);
-    for (const p of lockPaths) diag(`    ${path16.relative(process.cwd(), p)}`);
-    if (!args.claims.length) {
+    for (const p of lockPaths) diag(`    ${path18.relative(process.cwd(), p)}`);
+    if (!args.claims.length && !args.workspace) {
       diag(
         `
   Only this project's lockfile was consulted. If the account is shared,
-  pass every other project's lockfile via --claims a.json,b.json or you
-  will see their assets listed as unclaimed.`
+  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 === path18.resolve(args.manifest))) {
+      diag(
+        `
+  This project's manifest is not registered in the workspace catalog. Its own
+  lockfile is still included above, so this run's claim set is complete \u2014 but
+  \`pixelkiln workspace add ${args.manifest}\` would keep it aggregated too.`
       );
     }
     const claimed = await loadClaims(lockPaths);
@@ -5613,16 +6064,11 @@ async function main() {
   nothing to triage`);
       return;
     }
-    const siblings = [];
-    for (const claimPath of args.claims.map((c) => path16.resolve(c))) {
-      const siblingManifestPath = path16.join(path16.dirname(claimPath), "pixelkiln.manifest.json");
-      if (!existsSync14(siblingManifestPath)) continue;
-      try {
-        const siblingLoaded = await loadManifest(siblingManifestPath);
-        siblings.push({ label: path16.basename(path16.dirname(siblingManifestPath)), manifest: siblingLoaded.manifest });
-      } catch {
-      }
-    }
+    const siblings = await loadSiblingManifests(
+      args.manifest,
+      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;
     if (multiStyle) {
@@ -5685,7 +6131,7 @@ async function main() {
           manifestPath: loaded.path,
           manifest: loaded.manifest,
           styleId,
-          importDir: path16.resolve(loaded.root, style.outDir),
+          importDir: path18.resolve(loaded.root, style.outDir),
           lock,
           lockPath: args.lock
         },