@mutmutco/codex-plugin 4.5.89 → 4.5.90

package/cli/dist/main.cjs

@@ -965,6 +965,8 @@ var init_house_map = __esm({
       train: "devops",
       suite: "devops",
       // #7264: cross-repo stage and served-version visibility
+      packages: "devops",
+      // #7833: consumer adoption of a verified package export
       "wave land": "devops",
       // the write-side serial merge train is shipping, not board observation
       bootstrap: "devops",
@@ -4745,7 +4747,7 @@ function useColor() {
 var program = new Command();
 
 // src/command-composition.ts
-var import_node_fs53 = require("node:fs");
+var import_node_fs54 = require("node:fs");
 init_clean_exit();
 init_cli_shared();
 
@@ -5647,8 +5649,8 @@ function resolveVerbAliasShim(argv) {
 }
 
 // src/command-composition.ts
-var import_node_os23 = require("node:os");
-var import_node_path52 = require("node:path");
+var import_node_os24 = require("node:os");
+var import_node_path53 = require("node:path");
 
 // src/board-read.ts
 var import_node_fs13 = require("node:fs");
@@ -14524,6 +14526,24 @@ async function activateProductRuleset(repo, rulesetBody, client, enforcement = "
   await client.rest("POST", `repos/${repo}/rulesets`, { body: { ...rulesetBody, enforcement }, timeoutMs: 2e4 });
   return { action: "created", enforcement };
 }
+async function gateContextEnforced(repo, rest) {
+  try {
+    const list = await rest(`repos/${repo}/rulesets?includes_parents=true`);
+    for (const entry of list) {
+      if (entry.id == null) continue;
+      const rs = await rest(`repos/${repo}/rulesets/${entry.id}`);
+      if (rs.target !== "branch" || rs.enforcement !== "active") continue;
+      const hit = (rs.rules ?? []).some((r) => r.type === "required_status_checks" && (r.parameters?.required_status_checks ?? []).some((c) => c.context === PRODUCT_GATE_CONTEXT));
+      if (hit) return true;
+    }
+    return false;
+  } catch {
+    return false;
+  }
+}
+async function propagateMayAutoMerge(repo, repoClass, rest) {
+  return repoClass === "content" || gateContextEnforced(repo, rest);
+}
 
 // src/bootstrap-apply.ts
 var import_node_crypto5 = require("node:crypto");
@@ -17225,10 +17245,10 @@ var rollout_plan_default = {
     note: "The v4.0.0 stamp happens at cut time (D6e #4463); until then the candidate is the origin/development head artifacts (built cli/dist + npm pack), identity proven by dist content hash (D6a)."
   },
   baseline: {
-    version: "4.5.89",
-    tag: "v4.5.89",
-    commit: "3288efa7a0af",
-    npm: "@mutmutco/cli@4.5.89"
+    version: "4.5.90",
+    tag: "v4.5.90",
+    commit: "f096038f4a17",
+    npm: "@mutmutco/cli@4.5.90"
   },
   exitCriterion: "fleet-n-of-n",
   hubOnlyShortcut: "forbidden",
@@ -17245,14 +17265,14 @@ var rollout_plan_default = {
           repo: "mutmutco/mmi-hub",
           role: "canary",
           schedule: "train",
-          v3Target: "v4.5.89"
+          v3Target: "v4.5.90"
         }
       ],
       rollbackTrigger: "Any red inside the post-contract soak window: `devops train gate` FAIL attributable to the v4 doors, Hub endpoint health probe failure, a pre-v4 client admitted instead of receiving actionable HTTP 426, or npm consumer install/doctor failure on the v4-only dist.",
       rollback: {
         independent: true,
-        mechanism: "npm dist-tag latest -> 4.5.89 and redeploy the Hub Lambda from tag v4.5.89 (3288efa7a0af); installed clients repair via `mmi-cli doctor`. No other cohort is touched.",
-        v3Target: "v4.5.89 (@mutmutco/cli@4.5.89, tag commit 3288efa7a0af \u2014 last known-good release carrying the repo-index v4-only contract)"
+        mechanism: "npm dist-tag latest -> 4.5.90 and redeploy the Hub Lambda from tag v4.5.90 (f096038f4a17); installed clients repair via `mmi-cli doctor`. No other cohort is touched.",
+        v3Target: "v4.5.90 (@mutmutco/cli@4.5.90, tag commit f096038f4a17 \u2014 last known-good release carrying the repo-index v4-only contract)"
       }
     },
     {
@@ -28972,7 +28992,7 @@ var PRIMARY_GROUPS = [
   ["Setup and support", ["bootstrap", "secrets", "docs", "tests", "spawn", "dist"]],
   ["Coordinate and improve", ["wave", "report", "skill-lesson", "closure-rate"]]
 ];
-var OPERATIONAL_TOP_LEVEL = /* @__PURE__ */ new Set(["org", "runtime", "plugin"]);
+var OPERATIONAL_TOP_LEVEL = /* @__PURE__ */ new Set(["org", "runtime", "plugin", "packages"]);
 var CAMPAIGN_ORCHESTRATOR_TOP_LEVEL = /* @__PURE__ */ new Set(["pickup"]);
 var SUPPORT_PRIMARY = /* @__PURE__ */ new Set(["doctor", "whoami", "commands", "explain", "docs", "tests", "spawn", "dist", "wave", "report", "skill-lesson", "closure-rate"]);
 var TOP_LEVEL_ORDER = /* @__PURE__ */ new Map();
@@ -29020,6 +29040,8 @@ var COMMAND_OWNERSHIP = {
   train: { module_owner: "cli/src/train-commands.ts", consumer: "release-operator" },
   suite: { module_owner: "cli/src/suite-commands.ts", consumer: "release-operator" },
   // #7264
+  packages: { module_owner: "cli/src/packages-adopt-export.ts", consumer: "agent-workflow" },
+  // #7833
   bootstrap: { module_owner: "cli/src/bootstrap-commands.ts", consumer: "repo-bootstrap" },
   secrets: { module_owner: "cli/src/secrets-commands.ts", consumer: "authenticated-operator" },
   docs: { module_owner: "cli/src/docs-index-command.ts", consumer: "repo-gates" },
@@ -30595,16 +30617,6 @@ function loadPortRegistry(path2) {
   }
   return out;
 }
-function ensurePortRange(repo, path2) {
-  const registry2 = loadPortRegistry(path2);
-  const existing = registry2[repo];
-  if (existing) return existing;
-  const range = nextPortBlock(registry2);
-  const raw = (0, import_node_fs25.existsSync)(path2) ? JSON.parse((0, import_node_fs25.readFileSync)(path2, "utf8")) : {};
-  raw[repo] = range;
-  (0, import_node_fs25.writeFileSync)(path2, JSON.stringify(raw, null, 2) + "\n", "utf8");
-  return range;
-}
 function portCursorSeed(registry2) {
   return nextPortBlock(registry2)[0];
 }
@@ -30645,7 +30657,7 @@ function resolvePortRangeInfra(cwd, packageDir) {
   }
   return null;
 }
-async function ensurePortRangeAtomic(repo, path2, allocate, opts = {}) {
+async function ensurePortRangeAtomic(repo, path2, allocate) {
   const registry2 = loadPortRegistry(path2);
   const existing = existingPortRange(repo, registry2);
   if (existing) return { range: existing, source: "existing" };
@@ -30654,8 +30666,9 @@ async function ensurePortRangeAtomic(repo, path2, allocate, opts = {}) {
     const range = await allocate(seed);
     return { range, source: "ddb" };
   } catch (e) {
-    if (!opts.quiet) console.warn(`port-registry: DDB allocator unreachable, falling back to committed file (${e.message})`);
-    return { range: ensurePortRange(repo, path2), source: "file" };
+    const why = e.message;
+    const missing = /@aws-sdk\/[\w-]+/.exec(why)?.[0];
+    throw new Error(`DDB port allocator failed for ${repo} \u2014 refusing to fall back to the frozen ${path2} (it would hand out a block the cursor already gave away). ` + (missing && /cannot find|not found|ERR_MODULE_NOT_FOUND/i.test(why) ? `Missing dependency ${missing}: run \`npm ci\` in ${(0, import_node_path25.dirname)(path2)}, then retry.` : "Check AWS credentials and that the registry table is reachable, then retry.") + ` Cause: ${why}`);
   }
 }
 
@@ -30683,7 +30696,13 @@ async function assignPersistedPortRange(repo, slug, reg, opts) {
     if (!Array.isArray(parsed.range) || parsed.range.length !== 2) throw new Error("port-ddb: no range in output");
     return parsed.range;
   };
-  const { range: [start, end], source } = await ensurePortRangeAtomic(repo, path2, allocate);
+  let result;
+  try {
+    result = await ensurePortRangeAtomic(repo, path2, allocate);
+  } catch (e) {
+    return { ok: false, error: e.message };
+  }
+  const { range: [start, end], source } = result;
   const write = await upsertProject(slug, { portRange: { start, end } }, reg);
   if (!write.ok && source === "ddb") {
     return {
@@ -34144,7 +34163,7 @@ async function prepareTargetedSeedBranch(repo, plan, target, client, gh2) {
   }
   await verifyTargetedSeedBranch(repo, plan, target, client);
 }
-async function enableTargetedSeedAutoMerge(repo, number, plan, target, expected, client, gh2) {
+async function verifyTargetedSeedPr(repo, number, plan, target, expected, client) {
   const head = await verifyTargetedSeedBranch(repo, plan, target, client);
   const pr = await client.rest("GET", `repos/${repo}/pulls/${number}`);
   if (pr?.state !== "open" || pr.head?.ref !== plan.branch || pr.head?.sha !== head || pr.head.repo?.full_name?.toLowerCase() !== repo.toLowerCase() || pr.base?.ref !== plan.baseBranch || pr.base.sha !== plan.baseSha || pr.base.repo?.full_name?.toLowerCase() !== repo.toLowerCase() || pr.changed_files !== 1) throw new Error("bootstrap apply: scoped seed PR identity or diff changed");
@@ -34159,7 +34178,7 @@ async function enableTargetedSeedAutoMerge(repo, number, plan, target, expected,
   if (file?.content !== expected) {
     throw new Error("bootstrap apply: scoped seed content differs from this invocation");
   }
-  await gh2(["pr", "merge", String(number), "--repo", repo, "--auto", "--squash", "--match-head-commit", head]);
+  return head;
 }
 
 // src/bootstrap-commands.ts
@@ -34843,8 +34862,6 @@ function registerBootstrapCommands(program3) {
     let seedPrUrl;
     const scopedHead = o.execute && scopedPlan?.branch && configGateAction?.action !== "skip" ? await verifyTargetedSeedBranch(repo, scopedPlan, onlyTarget, controlClient) : null;
     if (o.execute && seedPlan.mode === "pr" && seedPlan.branch && configGateAction?.action !== "skip" && (seededToBranch > 0 || scopedContent !== void 0 && scopedHead !== null && scopedHead !== scopedPlan?.baseSha)) {
-      await gh2(["api", "-X", "PATCH", `repos/${repo}`, "-f", "allow_auto_merge=true", "-f", "allow_squash_merge=true", "-F", `delete_branch_on_merge=${MANAGED_DELETE_BRANCH_ON_MERGE}`]).catch(() => {
-      });
       const openPrs = await gh2(["pr", "list", "--repo", repo, "--head", seedPlan.branch, "--base", baseBranch, "--state", "open", "--json", "number,url"]);
       const prDecision = decideSeedPrAction(JSON.parse(openPrs.stdout || "[]"));
       if (prDecision.action === "reuse") {
@@ -34870,22 +34887,13 @@ ${onlyManagedBlock ? `Only the marker-bounded Hub-managed block inside repo-owne
         ]), "bootstrap apply pr create");
         seedPrUrl = created.url;
       }
-      let autoMergeEnabled = true;
+      const number = Number(seedPrUrl.split("/").pop());
       if (scopedPlan) {
         if (scopedContent === void 0) throw new Error("bootstrap apply: scoped seed content is unresolved");
-        const number = Number(seedPrUrl.split("/").pop());
         if (!Number.isInteger(number) || number <= 0) throw new Error("bootstrap apply: scoped seed PR number is unreadable");
-        await enableTargetedSeedAutoMerge(repo, number, scopedPlan, onlyTarget, scopedContent, controlClient, gh2);
-      } else await gh2(["pr", "merge", seedPrUrl, "--repo", repo, "--auto", "--squash"]).catch((e) => {
-        const message2 = String(e.message ?? "");
-        if (/already/i.test(message2)) return;
-        if (/clean status|enablePullRequestAutoMerge/i.test(message2)) {
-          autoMergeEnabled = false;
-          return;
-        }
-        throw e;
-      });
-      applied.push(autoMergeEnabled ? `seed: PR ${seedPrUrl} (base ${baseBranch} protected; auto-merge enabled)` : `seed: PR ${seedPrUrl} (base ${baseBranch} protected; auto-merge refused \u2014 PR is already clean. Land it: mmi-cli devops pr land <n> --repo ${repo})`);
+        await verifyTargetedSeedPr(repo, number, scopedPlan, onlyTarget, scopedContent, controlClient);
+      }
+      applied.push(`seed: PR ${seedPrUrl} (base ${baseBranch} protected; left open, never merged by apply \u2014 land it once its gate is green: mmi-cli devops pr land ${number} --repo ${repo})`);
     }
     if (o.execute && !onlyTarget) {
       const desiredBranches = branchesForTrack(effectiveTrack);
@@ -34932,6 +34940,7 @@ ${onlyManagedBlock ? `Only the marker-bounded Hub-managed block inside repo-owne
         applied.push(`has_wiki=false (failed: ${e.message})`);
       }
     }
+    const deferredFailures = [];
     if (o.execute && !onlyTarget && o.class === "deployable") {
       try {
         await gh2(["api", "-X", "PATCH", `repos/${repo}`, "-f", "allow_auto_merge=true", "-f", "allow_squash_merge=true", "-F", `delete_branch_on_merge=${MANAGED_DELETE_BRANCH_ON_MERGE}`]);
@@ -34947,9 +34956,7 @@ ${onlyManagedBlock ? `Only the marker-bounded Hub-managed block inside repo-owne
             const client = controlClient;
             const gateFacts = await readBootstrapGitHubFacts(repo, effectiveTrack, client);
             const rulesetBlockers = bootstrapControlWriteBlockers(gateFacts, true);
-            if (rulesetBlockers.length) {
-              return failGraceful(`bootstrap apply: product ruleset facts became unreadable before PUT; refusing write: ${rulesetBlockers.join("; ")}`);
-            }
+            if (rulesetBlockers.length) throw new Error(`facts became unreadable before PUT; refusing write: ${rulesetBlockers.join("; ")}`);
             const activation = await activateProductRuleset(
               repo,
               stripRulesetComment(rulesetContent),
@@ -34960,7 +34967,8 @@ ${onlyManagedBlock ? `Only the marker-bounded Hub-managed block inside repo-owne
               `product ruleset: ${activation.action} (${activation.enforcement}${activation.detail ? `; ${activation.detail}` : ""})` + (activation.enforcement === "active" ? "" : ` \u2014 ${PRODUCT_GATE_PATH2} has not emitted a proven-green context on ${baseBranch}, so it is NOT enforcing. Re-run bootstrap apply after the gate passes; ci reconcile --apply remains the supported fallback.`)
             );
           } catch (e) {
-            return failGraceful(`bootstrap apply: product ruleset activation failed: ${e.message}`);
+            deferredFailures.push(`product ruleset not written (${e.message}) \u2014 re-run bootstrap apply once ${PRODUCT_GATE_PATH2} has a completed run`);
+            applied.push(`product ruleset (REFUSED: ${e.message})`);
           }
         }
       }
@@ -35047,6 +35055,7 @@ ${onlyManagedBlock ? `Only the marker-bounded Hub-managed block inside repo-owne
             );
           } else {
             applied.push(`portRange (failed: ${assigned.error})`);
+            deferredFailures.push(`portRange not assigned: ${assigned.error}`);
           }
         }
       } else {
@@ -35124,6 +35133,8 @@ ${renderBootstrapAncillaryPlan(ancillaryPlan, environmentPlan, repoEnvironmentSp
 LIVE apply to ${repo}:
   ${applied.join("\n  ")}`);
     }
+    if (deferredFailures.length) return failGraceful(`bootstrap apply: incomplete \u2014 every other step ran:
+  ${deferredFailures.join("\n  ")}`);
   });
   bootstrap.command("propagate").description("#4238: re-entrant canary\u2192wave tick \u2014 plan (or, with --execute, open) per-repo PRs fanning an org-owned seed out to the fleet").option("--target <path>", "the manifest target to propagate (an org-owned whole file or declared Hub-managed block)").option("--execute", "LIVE tick via gh (master-gated) \u2014 opens/reuses per-repo seed-propagate PRs; dry-run prints the plan only").option("--json", "machine-readable output").action(async () => {
     const o = { target: rawValue("--target", ""), execute: rawFlag("--execute"), json: rawFlag("--json") };
@@ -35371,8 +35382,10 @@ Rollback: \`mmi-cli devops bootstrap rollback ${rec.repo} --target ${seed.target
           prUrl = created.url;
         }
         if (rec.wave !== 0) {
-          await gh2(["pr", "merge", prUrl, "--repo", rec.repo, "--auto", "--squash"]).catch(() => {
+          const enforced = await propagateMayAutoMerge(rec.repo, classOf(rec.repo), async (path2) => JSON.parse((await gh2(["api", path2])).stdout || "[]"));
+          if (enforced) await gh2(["pr", "merge", prUrl, "--repo", rec.repo, "--auto", "--squash"]).catch(() => {
           });
+          else console.error(`bootstrap propagate: ${rec.repo} does not enforce the gate \u2014 auto-merge not armed; land it with: mmi-cli devops pr land ${prUrl.split("/").pop()} --repo ${rec.repo}`);
         }
         rec.prUrl = prUrl;
       }
@@ -37054,9 +37067,9 @@ A hotfix branch is cut from origin/main and carries ONLY the fixes --from names,
 async function preflightHotfixBatchPicks(deps, sources, pickTolerated) {
   if (sources.length === 0) return { failures: [], skipped: [] };
   const { mkdtemp: mkdtemp2, rm: rm2 } = await import("node:fs/promises");
-  const { tmpdir: tmpdir11 } = await import("node:os");
-  const { join: join46 } = await import("node:path");
-  const dir = await mkdtemp2(join46(tmpdir11(), "mmi-hotfix-preflight-"));
+  const { tmpdir: tmpdir12 } = await import("node:os");
+  const { join: join47 } = await import("node:path");
+  const dir = await mkdtemp2(join47(tmpdir12(), "mmi-hotfix-preflight-"));
   const wt = { run: (file, args) => deps.run(file, file === "git" ? ["-C", dir, ...args] : args) };
   const failures = [];
   const skipped = [];
@@ -47591,16 +47604,732 @@ function suiteStatusDeps(github, registry2) {
   };
 }
 
+// src/packages-adopt-export.ts
+var import_node_child_process18 = require("node:child_process");
+var import_node_fs45 = require("node:fs");
+var import_node_os21 = require("node:os");
+var import_node_path44 = require("node:path");
+var import_node_util6 = require("node:util");
+init_cli_shared();
+
+// ../scripts/package_export.py
+var package_export_default = `#!/usr/bin/env python3
+"""Export and offline verification of exact original package registry archives (#7805)."""
+import base64
+import binascii
+from datetime import datetime, timedelta, timezone
+import gzip
+import hashlib
+import hmac
+import io
+import json
+import os
+import pathlib
+import re
+import stat
+import struct
+import sys
+import tarfile
+import zipfile
+import zlib
+import urllib.error
+import urllib.request
+from urllib.parse import urlsplit
+
+PACKAGES = ("@mutmutco/mmwork-ds", "@mutmutco/mmwork-screens")
+MAX_METADATA_BYTES = 2 * 1024 * 1024
+MAX_TARBALL_BYTES = 64 * 1024 * 1024
+MAX_ARTIFACT_BYTES = 160 * 1024 * 1024
+MAX_ZIP_DIRECTORY_BYTES = 8192
+MAX_UNPACKED_BYTES = 256 * 1024 * 1024
+MAX_MEMBERS = 10000  # Yielded entries; tarfile consumes PAX/GNU extension headers internally.
+MAX_PATH_LENGTH = 1024
+MAX_PATH_DEPTH = 32
+MAX_COMPONENT_LENGTH = 255
+WINDOWS_DEVICE = re.compile(r"con|conin\\$|conout\\$|prn|aux|nul|com[1-9]|lpt[1-9]", re.IGNORECASE)
+EXACT_VERSION = re.compile(
+    r"(0|[1-9][0-9]*)\\.(0|[1-9][0-9]*)\\.(0|[1-9][0-9]*)"
+    r"(?:-([0-9A-Za-z-]+(?:\\.[0-9A-Za-z-]+)*))?"
+    r"(?:\\+[0-9A-Za-z-]+(?:\\.[0-9A-Za-z-]+)*)?"
+)
+
+
+def reject_constant(_):
+    raise ValueError("nonstandard-json")
+
+
+def unique_object(pairs):
+    result = {}
+    for key, value in pairs:
+        if key in result:
+            raise ValueError("registry-metadata")
+        result[key] = value
+    return result
+
+
+def verify_artifact_digest(provider_digest, zip_bytes):
+    """Bind whole bytes to an independently trusted provider digest, not an embedded claim.
+
+    This does not authenticate the digest's source or validate ZIP members.
+    """
+    if (type(zip_bytes) is not bytes or not 0 < len(zip_bytes) <= MAX_ARTIFACT_BYTES
+            or type(provider_digest) is not str
+            or not re.fullmatch(r"sha256:[0-9a-f]{64}", provider_digest)):
+        raise ValueError("artifact-integrity")
+    digest = hashlib.sha256(zip_bytes).hexdigest()
+    if not hmac.compare_digest(provider_digest[7:], digest):
+        raise ValueError("artifact-integrity")
+    return {"artifactSha256": digest, "artifactBytes": len(zip_bytes)}
+
+
+def verify_artifact_receipt(provider_bytes, zip_bytes, expected, now):
+    """Check separately supplied provider metadata against trusted external selectors.
+
+    The caller must obtain metadata and selectors independently of the artifact.
+    This cannot authenticate their origin or establish workflow/requester authority.
+    Optional node_id, url, archive_download_url and updated_at are ignored, not validated.
+    """
+    keys = {"artifactId", "artifactName", "repositoryId", "runId", "headSha", "headBranch", "digest"}
+    try:
+        if type(expected) is not dict:
+            raise ValueError()
+        expected = expected.copy()
+        if set(expected) != keys:
+            raise ValueError()
+        if any(type(expected[key]) is not int or not 0 < expected[key] < (1 << 53)
+               for key in ("artifactId", "repositoryId", "runId")):
+            raise ValueError()
+        if (type(expected["headSha"]) is not str or not re.fullmatch(r"[0-9a-f]{40}", expected["headSha"])
+                or any(type(expected[key]) is not str or not 0 < len(expected[key]) <= 128
+                       or any(ord(char) < 33 or ord(char) > 126 for char in expected[key])
+                       for key in ("artifactName", "headBranch"))):
+            raise ValueError()
+        if type(provider_bytes) is not bytes or not 0 < len(provider_bytes) <= MAX_METADATA_BYTES:
+            raise ValueError()
+        provider = json.loads(provider_bytes.decode("utf-8"), object_pairs_hook=unique_object,
+                              parse_constant=reject_constant)
+        required = {"id", "name", "size_in_bytes", "digest", "expired", "created_at", "expires_at", "workflow_run"}
+        if (type(provider) is not dict or not required <= set(provider)
+                or set(provider) - required - {"node_id", "url", "archive_download_url", "updated_at"}):
+            raise ValueError()
+        run = provider["workflow_run"]
+        if (type(run) is not dict or set(run) != {"id", "repository_id", "head_repository_id", "head_sha", "head_branch"}
+                or provider["expired"] is not False):
+            raise ValueError()
+        if type(now) is not datetime or now.utcoffset() != timedelta(0):
+            raise ValueError()
+        dates = []
+        for key in ("created_at", "expires_at"):
+            value = provider[key]
+            if type(value) is not str or not re.fullmatch(r"[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9]{2}:[0-9]{2}:[0-9]{2}Z", value):
+                raise ValueError()
+            dates.append(datetime.strptime(value, "%Y-%m-%dT%H:%M:%SZ").replace(tzinfo=timezone.utc))
+        created, expires = dates
+        if not created <= now < expires or not timedelta(0) < expires - created <= timedelta(days=1):
+            raise ValueError()
+        for actual, wanted in [(provider["id"], expected["artifactId"]),
+                               (run["id"], expected["runId"]),
+                               (run["repository_id"], expected["repositoryId"]),
+                               (run["head_repository_id"], expected["repositoryId"])]:
+            if type(actual) is not int or actual != wanted:
+                raise ValueError()
+        for actual, wanted in [(provider["name"], expected["artifactName"]),
+                               (provider["digest"], expected["digest"]),
+                               (run["head_sha"], expected["headSha"]),
+                               (run["head_branch"], expected["headBranch"])]:
+            if type(actual) is not str or actual != wanted:
+                raise ValueError()
+        receipt = verify_artifact_digest(expected["digest"], zip_bytes)
+        if type(provider["size_in_bytes"]) is not int or provider["size_in_bytes"] != len(zip_bytes):
+            raise ValueError()
+    except (ValueError, RecursionError):
+        raise ValueError("artifact-receipt") from None
+    return {**expected, **receipt}
+
+
+def inspect_artifact_zip(zip_bytes):
+    """Read five proposed export members in memory without extracting or executing.
+
+    Authenticate whole artifact bytes before this stage. Returned member bytes still
+    require registry integrity checks; the manifest is untrusted, not an authority.
+    Byte/output limits are not a total process-memory budget, including codec remainders.
+    """
+    limits = {"manifest.json": MAX_METADATA_BYTES,
+              "mmwork-ds.metadata.json": MAX_METADATA_BYTES, "mmwork-ds.tgz": MAX_TARBALL_BYTES,
+              "mmwork-screens.metadata.json": MAX_METADATA_BYTES, "mmwork-screens.tgz": MAX_TARBALL_BYTES}
+    try:
+        if type(zip_bytes) is not bytes or not 0 < len(zip_bytes) <= MAX_ARTIFACT_BYTES:
+            raise ValueError()
+        stream = io.BytesIO(zip_bytes)
+        # ZipFile allocates every central-directory entry before application checks.
+        # Use stdlib's bounded EOCD reader and struct definitions for a strict profile audit.
+        end = zipfile._EndRecData(stream)
+        if (end is None or end[zipfile._ECD_SIGNATURE] != zipfile.stringEndArchive
+                or end[zipfile._ECD_DISK_NUMBER] != 0
+                or end[zipfile._ECD_DISK_START] != 0
+                or end[zipfile._ECD_ENTRIES_THIS_DISK] != len(limits)
+                or end[zipfile._ECD_ENTRIES_TOTAL] != len(limits)
+                or not 0 < end[zipfile._ECD_SIZE] <= MAX_ZIP_DIRECTORY_BYTES
+                or end[zipfile._ECD_COMMENT_SIZE] != 0
+                or end[zipfile._ECD_LOCATION] + zipfile.sizeEndCentDir != len(zip_bytes)
+                or end[zipfile._ECD_OFFSET] + end[zipfile._ECD_SIZE] != end[zipfile._ECD_LOCATION]):
+            raise ValueError()
+        directory = memoryview(zip_bytes)[end[zipfile._ECD_OFFSET]:end[zipfile._ECD_LOCATION]]
+        allowed = {name.encode("ascii") for name in limits}
+        seen = set()
+        cursor = 0
+        # ZipFile accepts short variable-field reads, so audit declared boundaries first.
+        while cursor < len(directory):
+            fields = struct.unpack_from(zipfile.structCentralDir, directory, cursor)
+            start = cursor + zipfile.sizeCentralDir
+            stop = start + fields[zipfile._CD_FILENAME_LENGTH]
+            if (fields[zipfile._CD_SIGNATURE] != zipfile.stringCentralDir
+                    or fields[zipfile._CD_EXTRA_FIELD_LENGTH] != 0 or fields[zipfile._CD_COMMENT_LENGTH] != 0
+                    or stop > len(directory)):
+                raise ValueError()
+            name = bytes(directory[start:stop])
+            if name not in allowed or name in seen:
+                raise ValueError()
+            seen.add(name)
+            cursor = stop
+        if cursor != len(directory) or seen != allowed:
+            raise ValueError()
+        with zipfile.ZipFile(stream, "r") as bundle:
+            entries = bundle.infolist()
+            if (bundle.start_dir != end[zipfile._ECD_OFFSET]
+                    or len(entries) != len(limits) or {entry.orig_filename for entry in entries} != set(limits)
+                    or min(entry.header_offset for entry in entries) != 0):
+                raise ValueError()
+            result = {}
+            entries.sort(key=lambda entry: entry.header_offset)
+            for index, entry in enumerate(entries):
+                if (entry.filename != entry.orig_filename or entry.is_dir()
+                        or stat.S_IFMT(entry.external_attr >> 16) not in (0, stat.S_IFREG)
+                        or entry.external_attr & 0x10 or entry.volume != 0
+                        or entry.flag_bits & ~(0x8 | 0x800)
+                        or entry.compress_type not in (zipfile.ZIP_STORED, zipfile.ZIP_DEFLATED)
+                        or entry.comment or entry.extra
+                        or not 0 < entry.file_size <= limits[entry.filename]
+                        or not 0 < entry.compress_size <= MAX_ARTIFACT_BYTES):
+                    raise ValueError()
+                header = entry.FileHeader(zip64=False)
+                start = entry.header_offset + len(header)
+                data_end = start + entry.compress_size
+                next_offset = entries[index + 1].header_offset if index + 1 < len(entries) else bundle.start_dir
+                if zip_bytes[entry.header_offset:start] != header or data_end > next_offset:
+                    raise ValueError()
+                span = next_offset - data_end
+                if span not in ((12, 16) if entry.flag_bits & 0x8 else (0,)):
+                    raise ValueError()
+                descriptor = zip_bytes[data_end:next_offset]
+                if entry.flag_bits & 0x8:
+                    fields = struct.pack("<III", entry.CRC, entry.compress_size, entry.file_size)
+                    if descriptor not in (fields, b"PK\\x07\\x08" + fields):
+                        raise ValueError()
+                elif descriptor:
+                    raise ValueError()
+                compressed = memoryview(zip_bytes)[start:data_end]
+                if entry.compress_type == zipfile.ZIP_STORED:
+                    if entry.compress_size != entry.file_size:
+                        raise ValueError()
+                    payload = bytes(compressed)
+                else:
+                    codec = zlib.decompressobj(wbits=-15)
+                    payload = codec.decompress(compressed, entry.file_size + 1)
+                    # ZipExtFile clips to the declared size and may ignore trailing data.
+                    if not codec.eof or codec.unused_data or codec.unconsumed_tail:
+                        raise ValueError()
+                if len(payload) != entry.file_size or zlib.crc32(payload) != entry.CRC:
+                    raise ValueError()
+                result[entry.filename] = payload
+        return result
+    except (ValueError, OSError, EOFError, NotImplementedError, zipfile.BadZipFile, zlib.error, struct.error):
+        raise ValueError("artifact-members") from None
+
+
+def inspect_archive(name, version, tarball_bytes):
+    seen = set()
+    files = set()
+    directories = set()
+    package = None
+    end = 0
+    try:
+        with gzip.GzipFile(fileobj=io.BytesIO(tarball_bytes)) as compressed:
+            unpacked = compressed.read(MAX_UNPACKED_BYTES + 1)
+        if len(unpacked) > MAX_UNPACKED_BYTES:
+            raise ValueError()
+        with tarfile.open(fileobj=io.BytesIO(unpacked), mode="r:") as archive:
+            for index, entry in enumerate(archive):
+                if (index >= MAX_MEMBERS or entry.size < 0 or entry.size > MAX_UNPACKED_BYTES
+                        or (entry.isdir() and entry.size != 0)):
+                    raise ValueError()
+                end = entry.offset_data + ((entry.size + 511) // 512) * 512
+                # Bound names before splitting or allocating retained ancestor prefixes.
+                if len(entry.name) > MAX_PATH_LENGTH:
+                    raise ValueError()
+                path = entry.name.rstrip("/") if entry.isdir() else entry.name
+                if path.count("/") >= MAX_PATH_DEPTH:
+                    raise ValueError()
+                parts = path.split("/")
+                if (not (entry.isreg() or entry.isdir()) or entry.issparse()
+                        or parts[0] != "package" or "\\\\" in path or ":" in path
+                        or any(ord(char) < 32 or ord(char) > 126 for char in path)
+                        or any(len(part) > MAX_COMPONENT_LENGTH or part in ("", ".", "..")
+                               or part.rstrip(". ") != part for part in parts)
+                        or path.lower() in seen):
+                    raise ValueError()
+                seen.add(path.lower())
+                folded = path.lower()
+                parents = ["/".join(parts[:i]).lower() for i in range(1, len(parts))]
+                if any(parent in files for parent in parents) or (entry.isreg() and folded in directories):
+                    raise ValueError()
+                directories.update(parents)
+                if entry.isdir():
+                    directories.add(folded)
+                else:
+                    files.add(folded)
+                for part in parts:
+                    lower = part.lower()
+                    if (WINDOWS_DEVICE.fullmatch(part.split(".", 1)[0].rstrip(" "))
+                            or any(char in part for char in '<>"|?*')
+                            or lower in (".npmrc", ".netrc", ".pypirc", ".git", ".gitconfig", ".git-credentials", ".yarnrc", ".yarnrc.yml")
+                            or lower.startswith(".env") or lower.endswith((".env", ".pem", ".key", ".p12", ".pfx", ".log"))):
+                        raise ValueError()
+                if path == "package/package.json":
+                    if not entry.isreg() or entry.size > MAX_METADATA_BYTES:
+                        raise ValueError()
+                    with archive.extractfile(entry) as file:
+                        package = json.loads(file.read().decode("utf-8"), object_pairs_hook=unique_object,
+                                             parse_constant=reject_constant)
+        if len(unpacked) - end < 1024 or any(unpacked[end:]):
+            raise ValueError()
+        if type(package) is not dict or package.get("name") != name or package.get("version") != version:
+            raise ValueError()
+    except (ValueError, tarfile.TarError, OSError, EOFError, RecursionError, zlib.error):
+        raise ValueError("archive-members") from None
+
+
+def check_exact_version(version):
+    match = EXACT_VERSION.fullmatch(version) if type(version) is str and len(version) <= 128 else None
+    if not match or any(
+        part.isdigit() and len(part) > 1 and part.startswith("0")
+        for part in (match[4] or "").split(".")
+    ):
+        raise ValueError("package-identity")
+
+
+def check_tarball_url(url):
+    # Accept literal paths only: never reinterpret percent escapes or empty delimiters.
+    if (type(url) is not str or any(ord(char) < 33 or ord(char) > 126 for char in url)
+            or any(char in url for char in "\\\\%?#")):
+        raise ValueError("registry-url")
+    try:
+        location = urlsplit(url)
+    except ValueError:
+        raise ValueError("registry-url") from None
+    if (location.scheme != "https" or location.netloc != "npm.pkg.github.com"
+            or not location.path.startswith("/download/")
+            or any(part in ("", ".", "..") for part in location.path.split("/")[1:])):
+        raise ValueError("registry-url")
+
+
+def verify_registry_archive(name, version, metadata_bytes, tarball_bytes):
+    if (type(metadata_bytes) is not bytes or not 0 < len(metadata_bytes) <= MAX_METADATA_BYTES
+            or type(tarball_bytes) is not bytes or not 0 < len(tarball_bytes) <= MAX_TARBALL_BYTES):
+        raise ValueError("byte-limit")
+    if type(name) is not str or name not in PACKAGES:
+        raise ValueError("package-identity")
+    check_exact_version(version)
+    try:
+        metadata = json.loads(metadata_bytes.decode("utf-8"), object_pairs_hook=unique_object,
+                              parse_constant=reject_constant)
+        if type(metadata) is not dict or type(metadata.get("dist")) is not dict:
+            raise ValueError()
+        full_integrity = metadata["dist"].get("integrity")
+        if type(full_integrity) is not str or not full_integrity.startswith("sha512-"):
+            raise ValueError()
+        registry_digest = base64.b64decode(full_integrity[7:], validate=True)
+        if (len(registry_digest) != hashlib.sha512().digest_size
+                or base64.b64encode(registry_digest).decode() != full_integrity[7:]):
+            raise ValueError()
+    except (ValueError, binascii.Error, RecursionError):
+        raise ValueError("registry-metadata") from None
+    if metadata.get("name") != name or metadata.get("version") != version:
+        raise ValueError("package-identity")
+    check_tarball_url(metadata["dist"].get("tarball"))
+    if not hmac.compare_digest(registry_digest, hashlib.sha512(tarball_bytes).digest()):
+        raise ValueError("integrity-mismatch")
+    inspect_archive(name, version, tarball_bytes)
+    return {
+        "name": name,
+        "version": version,
+        "integrity": metadata["dist"]["integrity"],
+        "metadataSha256": hashlib.sha256(metadata_bytes).hexdigest(),
+        "tarballSha256": hashlib.sha256(tarball_bytes).hexdigest(),
+        "metadataBytes": len(metadata_bytes),
+        "tarballBytes": len(tarball_bytes),
+    }
+
+
+# --- Export (runs only inside .github/workflows/package-export.yml) ---------------------------
+TRUSTED_REPOSITORY = "mutmutco/MMI-Hub"
+TRUSTED_WORKFLOW = ".github/workflows/package-export.yml"
+TRUSTED_REF = "refs/heads/development"
+REGISTRY = "https://npm.pkg.github.com"
+MAX_PACKUMENT_BYTES = 16 * 1024 * 1024
+VERSION_INPUTS = {"@mutmutco/mmwork-ds": "DS_VERSION", "@mutmutco/mmwork-screens": "SCREENS_VERSION"}
+
+
+def dispatch_identity(env):
+    """Refuse any run that is not this workflow, dispatched on the trusted ref of the trusted repo."""
+    try:
+        identity = {key: env[name] for key, name in [
+            ("repository", "GITHUB_REPOSITORY"), ("repositoryId", "GITHUB_REPOSITORY_ID"),
+            ("workflowRef", "GITHUB_WORKFLOW_REF"), ("ref", "GITHUB_REF"), ("headSha", "GITHUB_SHA"),
+            ("runId", "GITHUB_RUN_ID"), ("runAttempt", "GITHUB_RUN_ATTEMPT"),
+            ("event", "GITHUB_EVENT_NAME"), ("actor", "GITHUB_ACTOR"),
+            ("triggeringActor", "GITHUB_TRIGGERING_ACTOR")]}
+    except KeyError:
+        raise ValueError("dispatch-identity") from None
+    if (identity["repository"] != TRUSTED_REPOSITORY or identity["ref"] != TRUSTED_REF
+            or identity["event"] != "workflow_dispatch"
+            or identity["workflowRef"] != f"{TRUSTED_REPOSITORY}/{TRUSTED_WORKFLOW}@{TRUSTED_REF}"
+            or not re.fullmatch(r"[0-9a-f]{40}", identity["headSha"])
+            or not all(re.fullmatch(r"[1-9][0-9]{0,15}", identity[key])
+                       for key in ("repositoryId", "runId", "runAttempt"))
+            or not all(re.fullmatch(r"[A-Za-z0-9][A-Za-z0-9-]{0,38}(\\[bot\\])?", identity[key])
+                       for key in ("actor", "triggeringActor"))):
+        raise ValueError("dispatch-identity")
+    return identity
+
+
+class HttpsOnlyRedirect(urllib.request.HTTPRedirectHandler):
+    def redirect_request(self, req, fp, code, msg, headers, newurl):
+        if urlsplit(newurl).scheme != "https":
+            raise ValueError("registry-url")
+        return super().redirect_request(req, fp, code, msg, headers, newurl)
+
+
+def default_opener():
+    # No proxy handler: the token goes only to the registry host named in the request.
+    return urllib.request.build_opener(urllib.request.ProxyHandler({}), HttpsOnlyRedirect())
+
+
+def fetch(opener, url, token, limit):
+    request = urllib.request.Request(url, headers={"Accept": "application/json"})
+    # Unredirected: the registry's redirect to blob storage never carries the token.
+    request.add_unredirected_header("Authorization", f"Bearer {token}")
+    with opener.open(request, timeout=60) as response:
+        body = response.read(limit + 1)
+    if len(body) > limit or not body:
+        raise ValueError("byte-limit")
+    return body
+
+
+def export_package(opener, token, name, version):
+    check_exact_version(version)
+    try:
+        packument_bytes = fetch(opener, f"{REGISTRY}/{name.replace('/', '%2f')}", token, MAX_PACKUMENT_BYTES)
+    except urllib.error.HTTPError as error:
+        # Name the package and the registry's own short reason (body only; no request headers).
+        reason = error.read(300).decode("utf-8", "replace").replace(token, "***")
+        raise ValueError(f"registry {name}: HTTP {error.code} {reason}") from None
+    try:
+        packument = json.loads(packument_bytes.decode("utf-8"), object_pairs_hook=unique_object,
+                               parse_constant=reject_constant)
+        if (type(packument) is not dict or packument.get("name") != name
+                or type(packument.get("versions")) is not dict):
+            raise ValueError()
+        document = packument["versions"][version]
+        if type(document) is not dict or type(document.get("dist")) is not dict:
+            raise ValueError()
+    except (ValueError, KeyError, RecursionError):
+        raise ValueError("registry-metadata") from None
+    check_tarball_url(document["dist"].get("tarball"))
+    metadata_bytes = json.dumps(document, sort_keys=True, separators=(",", ":")).encode()
+    tarball_bytes = fetch(opener, document["dist"]["tarball"], token, MAX_TARBALL_BYTES)
+    receipt = verify_registry_archive(name, version, metadata_bytes, tarball_bytes)
+    receipt["packumentSha256"] = hashlib.sha256(packument_bytes).hexdigest()
+    return metadata_bytes, tarball_bytes, receipt
+
+
+def export(env, out_dir, opener=None):
+    """Write exactly the five artifact members into a new directory. Nothing else is written."""
+    identity = dispatch_identity(env)
+    versions = {name: env.get(variable) for name, variable in VERSION_INPUTS.items()}
+    for version in versions.values():
+        check_exact_version(version)
+    token = env.get("GITHUB_PACKAGES_TOKEN")
+    if type(token) is not str or not token.strip():
+        raise ValueError("registry-token")
+    opener = opener or default_opener()
+    files = {}
+    receipts = []
+    for name in PACKAGES:
+        metadata_bytes, tarball_bytes, receipt = export_package(opener, token, name, versions[name])
+        short = name.split("/")[1]
+        files[f"{short}.metadata.json"] = metadata_bytes
+        files[f"{short}.tgz"] = tarball_bytes
+        receipts.append(receipt)
+    manifest = {"schema": 1, "registry": REGISTRY, "source": identity, "packages": receipts}
+    files["manifest.json"] = json.dumps(manifest, sort_keys=True, indent=2).encode()
+    if any(token.encode() in payload for payload in files.values()):
+        raise ValueError("registry-token")
+    out = pathlib.Path(out_dir)
+    out.mkdir(parents=True, exist_ok=False)
+    for member, payload in files.items():
+        (out / member).write_bytes(payload)
+    return manifest
+
+
+def verify_export(provider_bytes, zip_bytes, expected, versions, now):
+    """Consumer side: bind the artifact to external selectors, then re-verify every package offline.
+
+    versions maps each allowlisted package to the exact version the consumer asked for. The
+    manifest inside the artifact is checked against recomputed receipts, never trusted.
+    """
+    receipt = verify_artifact_receipt(provider_bytes, zip_bytes, expected, now)
+    members = inspect_artifact_zip(zip_bytes)
+    if type(versions) is not dict or set(versions) != set(PACKAGES):
+        raise ValueError("package-identity")
+    packages = []
+    for name in PACKAGES:
+        short = name.split("/")[1]
+        packages.append(verify_registry_archive(name, versions[name], members[f"{short}.metadata.json"],
+                                                members[f"{short}.tgz"]))
+    try:
+        manifest = json.loads(members["manifest.json"].decode("utf-8"), object_pairs_hook=unique_object,
+                              parse_constant=reject_constant)
+        source = manifest["source"]
+        claimed = manifest["packages"]
+        if (manifest.get("registry") != REGISTRY or type(claimed) is not list or len(claimed) != len(packages)
+                or any(type(entry) is not dict or {key: entry.get(key) for key in package} != package
+                       for entry, package in zip(claimed, packages))
+                or source.get("repository") != TRUSTED_REPOSITORY
+                or source.get("workflowRef") != f"{TRUSTED_REPOSITORY}/{TRUSTED_WORKFLOW}@{TRUSTED_REF}"
+                or source.get("headSha") != expected["headSha"]
+                or source.get("runId") != str(expected["runId"])
+                or source.get("repositoryId") != str(expected["repositoryId"])):
+            raise ValueError()
+    except (ValueError, KeyError, TypeError, AttributeError, RecursionError):
+        raise ValueError("artifact-manifest") from None
+    return {"artifact": receipt, "packages": packages}
+
+
+def verify_dir(work_dir, ds_version, screens_version):
+    """Consumer CLI entry (#7833): verify_export over files a caller fetched into work_dir.
+
+    Reads provider.json, artifact.zip and expected.json; writes only the four verified package
+    members into work_dir/verified (a new directory). The caller acts only on those bytes.
+    """
+    work = pathlib.Path(work_dir)
+    result = verify_export((work / "provider.json").read_bytes(), (work / "artifact.zip").read_bytes(),
+                           json.loads((work / "expected.json").read_text("utf-8")),
+                           {PACKAGES[0]: ds_version, PACKAGES[1]: screens_version}, datetime.now(timezone.utc))
+    members = inspect_artifact_zip((work / "artifact.zip").read_bytes())
+    out = work / "verified"
+    out.mkdir(exist_ok=False)
+    for member, payload in members.items():
+        if member != "manifest.json":
+            (out / member).write_bytes(payload)
+    return result
+
+
+if __name__ == "__main__":
+    if len(sys.argv) == 5 and sys.argv[1] == "verify":
+        try:
+            print(json.dumps(verify_dir(*sys.argv[2:]), sort_keys=True, indent=2))
+        except (ValueError, OSError) as error:
+            sys.exit(f"package-export verify refused: {error}")
+        sys.exit(0)
+    if len(sys.argv) != 3 or sys.argv[1] != "export":
+        sys.exit("usage: package_export.py export <new-output-dir> | verify <work-dir> <ds-version> <screens-version>")
+    try:
+        result = export(os.environ, sys.argv[2])
+    except (ValueError, OSError, urllib.error.URLError) as error:
+        # Error text carries no request headers: HTTPError renders only the status line.
+        sys.exit(f"package-export refused: {error}")
+    print(json.dumps(result, sort_keys=True, indent=2))
+`;
+
+// src/packages-adopt-export.ts
+var EXPORT_REPO = "mutmutco/MMI-Hub";
+var EXPORT_WORKFLOW = ".github/workflows/package-export.yml";
+var PACKAGES = [
+  { name: "@mutmutco/mmwork-ds", short: "mmwork-ds" },
+  { name: "@mutmutco/mmwork-screens", short: "mmwork-screens" }
+];
+var SPEC_SECTIONS = ["dependencies", "devDependencies", "optionalDependencies"];
+var SHAPE_FIELDS = ["dependencies", "optionalDependencies", "peerDependencies", "peerDependenciesMeta", "bin", "os", "cpu", "hasInstallScript"];
+var stable = (value) => JSON.stringify(value, (_key, inner) => inner && typeof inner === "object" && !Array.isArray(inner) ? Object.fromEntries(Object.entries(inner).sort(([a], [b]) => a.localeCompare(b))) : inner);
+function lockShape(meta, field) {
+  if (field === "hasInstallScript") {
+    const scripts = meta.scripts ?? {};
+    return meta.hasInstallScript === true || Boolean(scripts.preinstall || scripts.install || scripts.postinstall) || void 0;
+  }
+  if (field === "bin" && meta.bin && typeof meta.bin === "object") {
+    return Object.fromEntries(Object.entries(meta.bin).map(([k, v]) => [k, String(v).replace(/^(\.\/)+/, "")]));
+  }
+  const value = meta[field];
+  return value && typeof value === "object" && Object.keys(value).length === 0 ? void 0 : value;
+}
+function formatLike(original, value) {
+  const indent = /\n([ \t]+)"/.exec(original)?.[1] ?? "  ";
+  const text = JSON.stringify(value, null, indent) + "\n";
+  return original.includes("\r\n") ? text.replace(/\n/g, "\r\n") : text;
+}
+function planAdoption(packageText, lockText, metadata) {
+  const pkg = JSON.parse(packageText);
+  const lock = JSON.parse(lockText);
+  const root = lock.packages?.[""];
+  if (lock.lockfileVersion < 2 || !root) throw new Error("package-lock.json must be lockfileVersion 2 or 3");
+  const result = { adopted: [], skipped: [] };
+  for (const { name } of PACKAGES) {
+    const section = SPEC_SECTIONS.find((key) => pkg[key]?.[name] !== void 0);
+    if (!section) {
+      result.skipped.push(name);
+      continue;
+    }
+    const meta = metadata[name];
+    const entry = lock.packages[`node_modules/${name}`];
+    if (!entry) throw new Error(`${name} is in package.json but not in package-lock.json; run a normal registry install first`);
+    const nested = Object.keys(lock.packages).filter((key) => key.endsWith(`/node_modules/${name}`));
+    if (nested.length) throw new Error(`${name} has nested lock copies (${nested.join(", ")}); adopt-export edits only the top-level entry`);
+    const changed = SHAPE_FIELDS.filter((field) => stable(field === "hasInstallScript" ? entry[field] || void 0 : entry[field]) !== stable(lockShape(meta, field)));
+    if (changed.length) {
+      throw new Error(`${name} ${entry.version} -> ${meta.version} changes ${changed.join(", ")}; that needs the registry, so adopt it through a normal install in CI instead`);
+    }
+    result.adopted.push({ name, from: entry.version, to: meta.version, resolved: meta.dist.tarball, integrity: meta.dist.integrity });
+    entry.version = meta.version;
+    entry.resolved = meta.dist.tarball;
+    entry.integrity = meta.dist.integrity;
+    for (const field of ["license", "engines"]) {
+      if (meta[field] === void 0) delete entry[field];
+      else entry[field] = meta[field];
+    }
+    pkg[section][name] = meta.version;
+    root[section] = { ...root[section], [name]: meta.version };
+  }
+  return { packageText: formatLike(packageText, pkg), lockText: formatLike(lockText, lock), result };
+}
+function expectedFromRun(run, opts) {
+  if (run.id !== opts.run || run.repository?.full_name !== EXPORT_REPO || run.path !== EXPORT_WORKFLOW) {
+    throw new Error(`run ${opts.run} is not a ${EXPORT_REPO} ${EXPORT_WORKFLOW} run`);
+  }
+  return {
+    artifactId: opts.artifact,
+    artifactName: `mmi-package-export-${run.id}-${run.run_attempt}`,
+    repositoryId: run.repository.id,
+    runId: run.id,
+    headSha: run.head_sha,
+    headBranch: run.head_branch,
+    digest: opts.digest
+  };
+}
+async function adoptExport(opts, deps) {
+  if (!/^sha256:[0-9a-f]{64}$/.test(opts.digest)) throw new Error("--digest must be sha256:<64 hex>, from the export run summary");
+  const packagePath = (0, import_node_path44.join)(opts.dir, "package.json");
+  const lockPath = (0, import_node_path44.join)(opts.dir, "package-lock.json");
+  const packageText = (0, import_node_fs45.readFileSync)(packagePath, "utf8");
+  const lockText = (0, import_node_fs45.readFileSync)(lockPath, "utf8");
+  const work = (0, import_node_fs45.mkdtempSync)((0, import_node_path44.join)((0, import_node_os21.tmpdir)(), "mmi-adopt-export-"));
+  try {
+    const run = JSON.parse((await deps.ghApi(`repos/${EXPORT_REPO}/actions/runs/${opts.run}`)).toString("utf8"));
+    (0, import_node_fs45.writeFileSync)((0, import_node_path44.join)(work, "expected.json"), JSON.stringify(expectedFromRun(run, opts)));
+    (0, import_node_fs45.writeFileSync)((0, import_node_path44.join)(work, "provider.json"), await deps.ghApi(`repos/${EXPORT_REPO}/actions/artifacts/${opts.artifact}`));
+    (0, import_node_fs45.writeFileSync)((0, import_node_path44.join)(work, "artifact.zip"), await deps.ghApi(`repos/${EXPORT_REPO}/actions/artifacts/${opts.artifact}/zip`));
+    const script = (0, import_node_path44.join)(work, "package_export.py");
+    (0, import_node_fs45.writeFileSync)(script, package_export_default);
+    await deps.python(script, ["verify", work, opts.ds, opts.screens]);
+    const verified = (0, import_node_path44.join)(work, "verified");
+    const metadata = Object.fromEntries(PACKAGES.map(({ name, short: short3 }) => [name, JSON.parse((0, import_node_fs45.readFileSync)((0, import_node_path44.join)(verified, `${short3}.metadata.json`), "utf8"))]));
+    const plan = planAdoption(packageText, lockText, metadata);
+    for (const { name } of plan.result.adopted) {
+      const short3 = PACKAGES.find((p) => p.name === name).short;
+      await deps.npm(["cache", "add", (0, import_node_path44.join)(verified, `${short3}.tgz`)], opts.dir);
+    }
+    (0, import_node_fs45.writeFileSync)(packagePath, plan.packageText);
+    (0, import_node_fs45.writeFileSync)(lockPath, plan.lockText);
+    try {
+      await deps.npm(["ci", "--offline", "--ignore-scripts", "--no-audit", "--no-fund"], opts.dir);
+    } catch (error) {
+      (0, import_node_fs45.writeFileSync)(packagePath, packageText);
+      (0, import_node_fs45.writeFileSync)(lockPath, lockText);
+      throw new Error(`npm ci --offline failed, package.json and package-lock.json restored: ${error.message}`);
+    }
+    return plan.result;
+  } finally {
+    (0, import_node_fs45.rmSync)(work, { recursive: true, force: true });
+  }
+}
+var execFileBuffer = (0, import_node_util6.promisify)(import_node_child_process18.execFile);
+var MAX_OUTPUT = 200 * 1024 * 1024;
+async function findPython() {
+  for (const bin of ["python3", "python"]) {
+    try {
+      await execFileBuffer(bin, ["-I", "-S", "-B", "-c", "import sys; sys.exit(0 if sys.version_info >= (3, 11) else 1)"], { windowsHide: true, timeout: 1e4 });
+      return bin;
+    } catch {
+    }
+  }
+  throw new Error("Python 3.11+ is required to run the Hub package-export verifier");
+}
+function adoptExportProdDeps() {
+  const failText = (error) => String(error?.stderr || error?.message || error).trim();
+  return {
+    ghApi: async (path2) => {
+      try {
+        return (await execFileBuffer("gh", ["api", "--method", "GET", path2], { encoding: "buffer", maxBuffer: MAX_OUTPUT, windowsHide: true, timeout: 3e5 })).stdout;
+      } catch (error) {
+        throw new Error(`gh api ${path2} failed: ${failText(error)}`);
+      }
+    },
+    python: async (script, args) => {
+      try {
+        return (await execFileBuffer(await findPython(), ["-I", "-S", "-B", script, ...args], { encoding: "utf8", maxBuffer: MAX_OUTPUT, windowsHide: true, timeout: 3e5 })).stdout;
+      } catch (error) {
+        throw new Error(failText(error));
+      }
+    },
+    npm: async (args, cwd) => {
+      const [file, argv] = process.platform === "win32" ? ["cmd.exe", ["/c", "npm", ...args]] : ["npm", args];
+      const env = Object.fromEntries(Object.entries(process.env).filter(([key]) => key.toLowerCase() !== "npm_config_allow_scripts"));
+      try {
+        return (await execFileBuffer(file, argv, { cwd, env, encoding: "utf8", maxBuffer: MAX_OUTPUT, windowsHide: true, timeout: 6e5 })).stdout;
+      } catch (error) {
+        throw new Error(`npm ${args[0]} failed: ${failText(error)}`);
+      }
+    }
+  };
+}
+function registerPackagesCommands(program3) {
+  const packages = program3.command("packages").description("consumer adoption of verified package exports (#7833)");
+  packages.command("adopt-export").description("verify a package-export artifact and install its exact kit pair offline, keeping registry URLs and SRI in the lock").requiredOption("--run <id>", "package-export workflow run id").requiredOption("--artifact <id>", "artifact id from the run summary").requiredOption("--digest <sha256:hex>", "artifact digest from the run summary").requiredOption("--ds <version>", "exact @mutmutco/mmwork-ds version").requiredOption("--screens <version>", "exact @mutmutco/mmwork-screens version").option("--dir <path>", "npm project holding package.json and package-lock.json", ".").action(async (opts) => {
+    const id = (value, flag) => {
+      if (!/^[1-9][0-9]{0,15}$/.test(value)) fail(`${flag} must be a numeric id`);
+      return Number(value);
+    };
+    try {
+      const result = await adoptExport({ ...opts, run: id(opts.run, "--run"), artifact: id(opts.artifact, "--artifact") }, adoptExportProdDeps());
+      for (const a of result.adopted) console.log(`adopted ${a.name} ${a.from} -> ${a.to} (${a.resolved}, ${a.integrity})`);
+      for (const name of result.skipped) console.log(`skipped ${name}: not a dependency in this package.json`);
+      console.log("npm ci --offline --ignore-scripts passed; commit package.json and package-lock.json");
+    } catch (error) {
+      fail(`packages adopt-export refused: ${error.message}`);
+    }
+  });
+}
+
 // src/discovery-commands.ts
 init_cli_shared();
 
 // src/wave-status.ts
-var import_node_fs45 = require("node:fs");
+var import_node_fs46 = require("node:fs");
 function readStageSummary(worktreePath) {
   const statePath = stageStatePath(worktreePath);
-  if (!(0, import_node_fs45.existsSync)(statePath)) return void 0;
+  if (!(0, import_node_fs46.existsSync)(statePath)) return void 0;
   try {
-    const state = JSON.parse((0, import_node_fs45.readFileSync)(statePath, "utf8"));
+    const state = JSON.parse((0, import_node_fs46.readFileSync)(statePath, "utf8"));
     const port = typeof state.port === "number" ? state.port : void 0;
     if (port == null || !Number.isInteger(port) || port <= 0) return void 0;
     return { port, url: typeof state.url === "string" ? state.url : void 0 };
@@ -47657,9 +48386,9 @@ async function collectWaveStatus(deps) {
 // src/discovery-commands.ts
 init_github_client();
 init_cli_shared();
-var import_node_fs46 = require("node:fs");
-var import_node_os21 = require("node:os");
-var import_node_path44 = require("node:path");
+var import_node_fs47 = require("node:fs");
+var import_node_os22 = require("node:os");
+var import_node_path45 = require("node:path");
 var GC_GH_TIMEOUT_MS3 = 2e4;
 async function collectStatus() {
   const repo = await resolveRepo();
@@ -47848,10 +48577,10 @@ async function collectOnboardStatus(opts = {}) {
     else if (top) nextCommand = `mmi-cli oracle board claim ${top.number}  # ${top.title}`;
     else nextCommand = "mmi-cli oracle board read \u2014 no claimable items found";
   }
-  const home = (0, import_node_os21.homedir)();
+  const home = (0, import_node_os22.homedir)();
   const plugin = onboardPluginGate({
-    readKnown: () => readFileSyncSafe((0, import_node_path44.join)(home, ...KNOWN_MARKETPLACES_RELATIVE), import_node_fs46.readFileSync),
-    readSettings: () => readFileSyncSafe((0, import_node_path44.join)(home, ".claude", "settings.json"), import_node_fs46.readFileSync)
+    readKnown: () => readFileSyncSafe((0, import_node_path45.join)(home, ...KNOWN_MARKETPLACES_RELATIVE), import_node_fs47.readFileSync),
+    readSettings: () => readFileSyncSafe((0, import_node_path45.join)(home, ".claude", "settings.json"), import_node_fs47.readFileSync)
   });
   return {
     guide: "Read the MMI org-guide skill before project work; load only the relevant topic. Use mmi-help for a short introduction.",
@@ -50955,8 +51684,8 @@ function registerSessionReport(program3) {
 }
 
 // src/stage-commands.ts
-var import_node_fs47 = require("node:fs");
-var import_node_path45 = require("node:path");
+var import_node_fs48 = require("node:fs");
+var import_node_path46 = require("node:path");
 init_cli_shared();
 init_clean_exit();
 
@@ -51202,8 +51931,8 @@ function registerStageCommands(program3) {
     return {
       resolution: decideStage({
         registry: { deployModel: project2?.deployModel, portRange, error: read.ok ? void 0 : read.error },
-        hasCompose: (0, import_node_fs47.existsSync)((0, import_node_path45.join)(process.cwd(), "docker-compose.yml")),
-        hasEnvExample: (0, import_node_fs47.existsSync)((0, import_node_path45.join)(process.cwd(), ".env.example")),
+        hasCompose: (0, import_node_fs48.existsSync)((0, import_node_path46.join)(process.cwd(), "docker-compose.yml")),
+        hasEnvExample: (0, import_node_fs48.existsSync)((0, import_node_path46.join)(process.cwd(), ".env.example")),
         repo
       }),
       project: project2,
@@ -51285,7 +52014,7 @@ vercel preview (${preview.branch}): ${d.state}${d.url ? ` \u2014 ${d.url}` : ""}
     if (!res.derived) return void 0;
     return result.port != null ? stageUrlForPort(result.port) : res.derived.url;
   }
-  program3.command("port-range <repo>").description("assign (idempotently) + print the repo's local stage port block via the atomic ORG#config.portCursor allocator (committed-file fallback)").option("--json", "machine-readable output").action(async (repo, o) => {
+  program3.command("port-range <repo>").description("assign (idempotently) + print the repo's local stage port block via the atomic ORG#config.portCursor allocator (fails loud when DDB is unreachable)").option("--json", "machine-readable output").action(async (repo, o) => {
     const cfg = await loadConfig();
     const reg = registryClientDeps(cfg);
     const slug = slugOf(repo);
@@ -51488,19 +52217,19 @@ vercel preview (${preview.branch}): ${d.state}${d.url ? ` \u2014 ${d.url}` : ""}
 
 // src/tenant-artifact.ts
 var import_node_crypto16 = require("node:crypto");
-var import_node_fs48 = require("node:fs");
+var import_node_fs49 = require("node:fs");
 var import_promises11 = require("node:fs/promises");
-var import_node_path46 = require("node:path");
+var import_node_path47 = require("node:path");
 var ARTIFACT_ID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
 var MAX_BYTES = 5 * 1024 * 1024 * 1024;
 async function sha256File(path2) {
   const hash = (0, import_node_crypto16.createHash)("sha256");
-  for await (const chunk of (0, import_node_fs48.createReadStream)(path2)) hash.update(chunk);
+  for await (const chunk of (0, import_node_fs49.createReadStream)(path2)) hash.update(chunk);
   return hash.digest("hex");
 }
 async function putTenantArtifact(repo, stage, inputPath, deps) {
   if (!["dev", "rc", "main"].includes(stage)) throw new Error("tenant artifact put: <stage> must be dev, rc, or main");
-  const path2 = (0, import_node_path46.resolve)(inputPath);
+  const path2 = (0, import_node_path47.resolve)(inputPath);
   const info = await (0, import_promises11.stat)(path2);
   if (!info.isFile()) throw new Error("tenant artifact put: input path must be a file");
   if (!Number.isSafeInteger(info.size) || info.size < 1 || info.size > MAX_BYTES) throw new Error(`tenant artifact put: file must be 1..${MAX_BYTES} bytes`);
@@ -51518,7 +52247,7 @@ async function putTenantArtifact(repo, stage, inputPath, deps) {
     return [key, value];
   }));
   headers["content-length"] = String(info.size);
-  const stream = (0, import_node_fs48.createReadStream)(path2);
+  const stream = (0, import_node_fs49.createReadStream)(path2);
   let uploaded;
   try {
     uploaded = await fetch(body.uploadUrl, {
@@ -51657,7 +52386,7 @@ function renderVerifySecrets(body) {
 }
 
 // src/command-register-developer.ts
-var import_node_fs52 = require("node:fs");
+var import_node_fs53 = require("node:fs");
 init_clean_exit();
 init_cli_shared();
 init_error_codes();
@@ -51690,7 +52419,7 @@ async function resolveWhoami(deps) {
 }
 
 // src/command-register-developer.ts
-var import_node_path51 = require("node:path");
+var import_node_path52 = require("node:path");
 init_house_map();
 init_hub_url();
 
@@ -51723,21 +52452,21 @@ async function executeWaveLand(plan, deps) {
 }
 
 // src/dist-drift.ts
-var import_node_child_process18 = require("node:child_process");
+var import_node_child_process19 = require("node:child_process");
 var import_node_crypto18 = require("node:crypto");
-var import_node_fs50 = require("node:fs");
-var import_node_os22 = require("node:os");
-var import_node_path48 = require("node:path");
+var import_node_fs51 = require("node:fs");
+var import_node_os23 = require("node:os");
+var import_node_path49 = require("node:path");
 
 // ../scripts/distribution-digest.mjs
 var import_node_crypto17 = require("node:crypto");
-var import_node_fs49 = require("node:fs");
-var import_node_path47 = require("node:path");
+var import_node_fs50 = require("node:fs");
+var import_node_path48 = require("node:path");
 var slash = (value) => value.replaceAll("\\", "/");
 function repoPath(root, declaredPath, label) {
-  const absoluteRoot = (0, import_node_path47.resolve)(root);
-  const target = (0, import_node_path47.resolve)(root, declaredPath);
-  if (target !== absoluteRoot && !target.startsWith(`${absoluteRoot}${import_node_path47.sep}`)) {
+  const absoluteRoot = (0, import_node_path48.resolve)(root);
+  const target = (0, import_node_path48.resolve)(root, declaredPath);
+  if (target !== absoluteRoot && !target.startsWith(`${absoluteRoot}${import_node_path48.sep}`)) {
     throw new Error(`${label} ${declaredPath} escapes the repository root`);
   }
   return target;
@@ -51745,7 +52474,7 @@ function repoPath(root, declaredPath, label) {
 function digestFiles(files) {
   const hash = (0, import_node_crypto17.createHash)("sha256");
   for (const file of [...files].sort((a, b) => a.relative.localeCompare(b.relative))) {
-    const content = file.stat.isSymbolicLink() ? Buffer.from((0, import_node_fs49.readlinkSync)(file.absolute), "utf8") : (0, import_node_fs49.readFileSync)(file.absolute);
+    const content = file.stat.isSymbolicLink() ? Buffer.from((0, import_node_fs50.readlinkSync)(file.absolute), "utf8") : (0, import_node_fs50.readFileSync)(file.absolute);
     hash.update(file.relative, "utf8");
     hash.update("\0");
     hash.update(file.stat.isSymbolicLink() ? "symlink" : "file", "utf8");
@@ -51760,8 +52489,8 @@ function digestFiles(files) {
 function digestPackedFiles(packageRoot, packedFiles) {
   return digestFiles(packedFiles.map((path2) => {
     const absolute = repoPath(packageRoot, path2, "packed artifact identity path");
-    if (!(0, import_node_fs49.existsSync)(absolute)) throw new Error(`packed artifact identity path ${path2} does not exist`);
-    return { absolute, relative: slash(path2), stat: (0, import_node_fs49.lstatSync)(absolute) };
+    if (!(0, import_node_fs50.existsSync)(absolute)) throw new Error(`packed artifact identity path ${path2} does not exist`);
+    return { absolute, relative: slash(path2), stat: (0, import_node_fs50.lstatSync)(absolute) };
   }));
 }
 
@@ -51845,13 +52574,13 @@ function renderDistDriftReceipt(receipt) {
   return lines2;
 }
 function readOrNull(path2) {
-  return (0, import_node_fs50.existsSync)(path2) ? (0, import_node_fs50.readFileSync)(path2) : null;
+  return (0, import_node_fs51.existsSync)(path2) ? (0, import_node_fs51.readFileSync)(path2) : null;
 }
 function walkFiles(root) {
   const files = [];
   const walk2 = (directory) => {
-    for (const entry of (0, import_node_fs50.readdirSync)(directory, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
-      const child2 = (0, import_node_path48.join)(directory, entry.name);
+    for (const entry of (0, import_node_fs51.readdirSync)(directory, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
+      const child2 = (0, import_node_path49.join)(directory, entry.name);
       if (entry.isDirectory()) walk2(child2);
       else files.push(child2);
     }
@@ -51861,14 +52590,14 @@ function walkFiles(root) {
 }
 function bomPathFor(root) {
   try {
-    const registry2 = JSON.parse((0, import_node_fs50.readFileSync)((0, import_node_path48.join)(root, "surfaces.json"), "utf8"));
-    return (0, import_node_path48.join)(root, registry2?.sharedAgentCore?.releaseMetadata?.bomPath ?? "distribution-bom.json");
+    const registry2 = JSON.parse((0, import_node_fs51.readFileSync)((0, import_node_path49.join)(root, "surfaces.json"), "utf8"));
+    return (0, import_node_path49.join)(root, registry2?.sharedAgentCore?.releaseMetadata?.bomPath ?? "distribution-bom.json");
   } catch {
-    return (0, import_node_path48.join)(root, "distribution-bom.json");
+    return (0, import_node_path49.join)(root, "distribution-bom.json");
   }
 }
 function rebuildTo(packageRoot, outDir) {
-  (0, import_node_child_process18.execFileSync)(process.execPath, ["build.mjs"], {
+  (0, import_node_child_process19.execFileSync)(process.execPath, ["build.mjs"], {
     cwd: packageRoot,
     env: { ...process.env, MMI_DIST_OUTDIR: outDir },
     windowsHide: true,
@@ -51877,35 +52606,35 @@ function rebuildTo(packageRoot, outDir) {
   });
 }
 function runDistStatus(root) {
-  const stage = (0, import_node_fs50.mkdtempSync)((0, import_node_path48.join)((0, import_node_os22.tmpdir)(), "mmi-dist-drift-"));
+  const stage = (0, import_node_fs51.mkdtempSync)((0, import_node_path49.join)((0, import_node_os23.tmpdir)(), "mmi-dist-drift-"));
   let overlayCount = 0;
   try {
-    const cliOut = (0, import_node_path48.join)(stage, "cli-dist");
-    const hubOut = (0, import_node_path48.join)(stage, "hub-dist");
-    rebuildTo((0, import_node_path48.join)(root, "cli"), cliOut);
-    rebuildTo((0, import_node_path48.join)(root, "updater"), hubOut);
+    const cliOut = (0, import_node_path49.join)(stage, "cli-dist");
+    const hubOut = (0, import_node_path49.join)(stage, "hub-dist");
+    rebuildTo((0, import_node_path49.join)(root, "cli"), cliOut);
+    rebuildTo((0, import_node_path49.join)(root, "updater"), hubOut);
     const outDirFor = (packageDir) => packageDir === "cli" ? cliOut : hubOut;
     const rebuilt = (path2) => {
       const spec = DIST_ARTIFACTS.find((entry) => entry.path === path2);
-      return spec ? readOrNull((0, import_node_path48.join)(outDirFor(spec.packageDir), spec.output)) : null;
+      return spec ? readOrNull((0, import_node_path49.join)(outDirFor(spec.packageDir), spec.output)) : null;
     };
-    const committed = (path2) => readOrNull((0, import_node_path48.join)(root, path2));
-    const tree = (path2) => readOrNull((0, import_node_path48.join)(root, path2));
-    const distRoot = (0, import_node_path48.join)(root, "cli", "dist");
-    const distTree = () => walkFiles(distRoot).map((absolute) => `cli/dist/${(0, import_node_path48.relative)(distRoot, absolute).replaceAll("\\", "/")}`);
-    const bom = JSON.parse((0, import_node_fs50.readFileSync)(bomPathFor(root), "utf8"));
+    const committed = (path2) => readOrNull((0, import_node_path49.join)(root, path2));
+    const tree = (path2) => readOrNull((0, import_node_path49.join)(root, path2));
+    const distRoot = (0, import_node_path49.join)(root, "cli", "dist");
+    const distTree = () => walkFiles(distRoot).map((absolute) => `cli/dist/${(0, import_node_path49.relative)(distRoot, absolute).replaceAll("\\", "/")}`);
+    const bom = JSON.parse((0, import_node_fs51.readFileSync)(bomPathFor(root), "utf8"));
     const digest = (entries) => {
-      const overlay = (0, import_node_path48.join)(stage, `overlay-${overlayCount++}`);
+      const overlay = (0, import_node_path49.join)(stage, `overlay-${overlayCount++}`);
       for (const entry of entries) {
-        const target = (0, import_node_path48.join)(overlay, entry.path);
-        (0, import_node_fs50.mkdirSync)((0, import_node_path48.dirname)(target), { recursive: true });
-        (0, import_node_fs50.writeFileSync)(target, entry.bytes);
+        const target = (0, import_node_path49.join)(overlay, entry.path);
+        (0, import_node_fs51.mkdirSync)((0, import_node_path49.dirname)(target), { recursive: true });
+        (0, import_node_fs51.writeFileSync)(target, entry.bytes);
       }
       return digestPackedFiles(overlay, entries.map((entry) => entry.path));
     };
     return computeDistDriftReceipt({ committed, tree, rebuilt, distTree, bom, digest });
   } finally {
-    (0, import_node_fs50.rmSync)(stage, { recursive: true, force: true });
+    (0, import_node_fs51.rmSync)(stage, { recursive: true, force: true });
   }
 }
 
@@ -51984,7 +52713,7 @@ init_hub_auth();
 
 // src/schedules-lift-command.ts
 var import_promises12 = require("node:fs/promises");
-var import_node_path49 = require("node:path");
+var import_node_path50 = require("node:path");
 init_clean_exit();
 init_cli_shared();
 var DEFAULT_WORKFLOWS_DIR = ".github/workflows";
@@ -52013,7 +52742,7 @@ async function readWorkflowFiles(dir) {
   const files = [];
   for (const name of names.sort()) {
     if (!/\.ya?ml$/.test(name)) continue;
-    files.push({ path: `.github/workflows/${name}`, text: await (0, import_promises12.readFile)((0, import_node_path49.join)(dir, name), "utf8") });
+    files.push({ path: `.github/workflows/${name}`, text: await (0, import_promises12.readFile)((0, import_node_path50.join)(dir, name), "utf8") });
   }
   return files;
 }
@@ -52095,9 +52824,9 @@ function registerSchedulesLiftCommand(program3, deps = {}) {
 }
 
 // src/spawn-policy-core.ts
-var import_node_child_process19 = require("node:child_process");
-var import_node_fs51 = require("node:fs");
-var import_node_path50 = require("node:path");
+var import_node_child_process20 = require("node:child_process");
+var import_node_fs52 = require("node:fs");
+var import_node_path51 = require("node:path");
 var SPAWNERS = ["spawn", "spawnSync", "exec", "execSync", "execFile", "execFileSync"];
 var CALL_SOURCE = String.raw`(^|[^.\w$])(${SPAWNERS.join("|")})\s*\(`;
 var SOURCE_EXT = /\.(ts|mts|cts|js|mjs|cjs)$/;
@@ -52166,7 +52895,7 @@ function findViolationsInSource(raw) {
   return found;
 }
 function policedFiles(root) {
-  const r = (0, import_node_child_process19.spawnSync)("git", ["ls-files", "-z", "--cached", "--others", "--exclude-standard"], {
+  const r = (0, import_node_child_process20.spawnSync)("git", ["ls-files", "-z", "--cached", "--others", "--exclude-standard"], {
     cwd: root,
     encoding: "utf8",
     windowsHide: true,
@@ -52183,7 +52912,7 @@ function runSpawnPolicy(root) {
   for (const file of files) {
     let raw;
     try {
-      raw = (0, import_node_fs51.readFileSync)((0, import_node_path50.join)(root, file), "utf8");
+      raw = (0, import_node_fs52.readFileSync)((0, import_node_path51.join)(root, file), "utf8");
     } catch {
       continue;
     }
@@ -52203,19 +52932,19 @@ function runSpawnPolicy(root) {
 function registerDeveloperCommands(program3) {
   const rules = program3.command("rules").description("org-managed .gitignore delivery");
   rules.command("gitignore").option("--write", "upsert the managed block into .gitignore (default: check only, non-zero exit on drift)").option("--json", "machine-readable output").description("verify (or --write) this repo's org-managed .gitignore block matches the SSOT").action((opts) => {
-    const path2 = (0, import_node_path51.join)(process.cwd(), ".gitignore");
-    const current = (0, import_node_fs52.existsSync)(path2) ? (0, import_node_fs52.readFileSync)(path2, "utf8") : null;
+    const path2 = (0, import_node_path52.join)(process.cwd(), ".gitignore");
+    const current = (0, import_node_fs53.existsSync)(path2) ? (0, import_node_fs53.readFileSync)(path2, "utf8") : null;
     const plan = planManagedGitignore(current);
     const drift = [...plan.added.map((l) => `+${l}`), ...plan.removed.map((l) => `-${l}`)].join(", ") || "block normalize";
     if (opts.json) {
-      if (opts.write && plan.changed) (0, import_node_fs52.writeFileSync)(path2, plan.content, "utf8");
+      if (opts.write && plan.changed) (0, import_node_fs53.writeFileSync)(path2, plan.content, "utf8");
       console.log(JSON.stringify(plan, null, 2));
       if (!opts.write && plan.changed) process.exitCode = 1;
       return;
     }
     if (opts.write) {
       if (plan.changed) {
-        (0, import_node_fs52.writeFileSync)(path2, plan.content, "utf8");
+        (0, import_node_fs53.writeFileSync)(path2, plan.content, "utf8");
         console.log(`mmi-cli devops org rules gitignore: updated .gitignore (${drift})`);
       } else {
         console.log("mmi-cli devops org rules gitignore: up to date");
@@ -52478,12 +53207,12 @@ ${r.stderr ?? ""}`).catch(() => "");
 var ENV_HEAL_LOCK_STALE_MS = 10 * 6e4;
 var ENV_HEAL_LOCK_MAX_WAIT_MS = 2 * 6e4;
 function envHealLockPath(home) {
-  return (0, import_node_path52.join)(home, ".claude", "plugins", ".mmi-env-heal.lock");
+  return (0, import_node_path53.join)(home, ".claude", "plugins", ".mmi-env-heal.lock");
 }
 async function withEnvHealLock(what, run) {
   try {
     return await withFileLock(
-      envHealLockPath((0, import_node_os23.homedir)()),
+      envHealLockPath((0, import_node_os24.homedir)()),
       { staleMs: ENV_HEAL_LOCK_STALE_MS, maxWaitMs: ENV_HEAL_LOCK_MAX_WAIT_MS, label: "mmi env-heal lock" },
       run
     );
@@ -52580,7 +53309,7 @@ function mmiDoctorDeps(opts = {}) {
       const configRoot = surfaceConfigRoot(surface);
       const running = surface === "codex" ? installedActivePluginVersion(surface) : runningPluginVersion(process.env, resolveClientVersion());
       const plan = buildPluginCachePlan(
-        (0, import_node_os23.homedir)(),
+        (0, import_node_os24.homedir)(),
         running,
         pluginCacheFsDeps(configRoot, () => 0),
         { configRoot, includeStaging: surface !== "codex" }
@@ -52608,14 +53337,14 @@ function mmiDoctorDeps(opts = {}) {
       const running = surface === "codex" ? installedActivePluginVersion(surface) : runningPluginVersion(process.env, resolveClientVersion());
       const installed = installedActivePluginVersion(surface);
       const plan = buildPluginCachePlan(
-        (0, import_node_os23.homedir)(),
+        (0, import_node_os24.homedir)(),
         running,
         pluginCacheFsDeps(configRoot, () => 0),
         { configRoot, includeStaging: surface !== "codex", installedVersion: installed }
       );
       const result = applyPluginCachePlan(
         plan,
-        (p) => (0, import_node_fs53.rmSync)(p, { recursive: true }),
+        (p) => (0, import_node_fs54.rmSync)(p, { recursive: true }),
         stagingApplyFsGuard(configRoot)
       );
       return {
@@ -52650,7 +53379,7 @@ function mmiDoctorDeps(opts = {}) {
     // has no generated routing index would
     // get a permanent — demanding an artifact it never asked for.
     docsIndexState: (root) => {
-      if (!(0, import_node_fs53.existsSync)((0, import_node_path52.join)(root, DOCS_INDEX_PATH))) return void 0;
+      if (!(0, import_node_fs54.existsSync)((0, import_node_path53.join)(root, DOCS_INDEX_PATH))) return void 0;
       const real = createDocsIndexDeps(root);
       let docs;
       const listDocs = () => docs ??= real.listDocs();
@@ -52659,7 +53388,7 @@ function mmiDoctorDeps(opts = {}) {
     },
     // #4168: working-tree heal — write if drifted, then re-check. Commit remains the operator's step.
     healDocsIndex: (root) => {
-      if (!(0, import_node_fs53.existsSync)((0, import_node_path52.join)(root, DOCS_INDEX_PATH))) return { drift: false, docCount: 0 };
+      if (!(0, import_node_fs54.existsSync)((0, import_node_path53.join)(root, DOCS_INDEX_PATH))) return { drift: false, docCount: 0 };
       const real = createDocsIndexDeps(root);
       let docs;
       const listDocs = () => docs ??= real.listDocs();
@@ -53367,7 +54096,7 @@ project.command("set [owner/repo]").description("upsert project META (idempotent
   if (dupe) return fail(`org project set: KEY "${dupe}" was passed to both --var and --set; --set is an alias of --var, so pass each KEY once`);
   if (o.secretsFile) {
     try {
-      vars.push(`secrets=${(0, import_node_fs53.readFileSync)(o.secretsFile, "utf8")}`);
+      vars.push(`secrets=${(0, import_node_fs54.readFileSync)(o.secretsFile, "utf8")}`);
     } catch (e) {
       return fail(`org project set: cannot read --secrets-file ${o.secretsFile}: ${e.message}`);
     }
@@ -53755,16 +54484,16 @@ function ciAuditDeps2() {
     // gate re-seed step is skipped gracefully rather than failing mid-run.
     readSeedFile: (path2) => {
       if (!root) return null;
-      const fullPath = (0, import_node_path52.join)(root, path2);
-      return (0, import_node_fs53.existsSync)(fullPath) ? (0, import_node_fs53.readFileSync)(fullPath, "utf8") : null;
+      const fullPath = (0, import_node_path53.join)(root, path2);
+      return (0, import_node_fs54.existsSync)(fullPath) ? (0, import_node_fs54.readFileSync)(fullPath, "utf8") : null;
     }
   };
 }
 function hubRoot2() {
-  const fromPkg = (0, import_node_path52.join)(__dirname, "..", "..");
+  const fromPkg = (0, import_node_path53.join)(__dirname, "..", "..");
   const marker = "skills/bootstrap/seeds/manifest.json";
-  if ((0, import_node_fs53.existsSync)((0, import_node_path52.join)(fromPkg, marker))) return fromPkg;
-  if ((0, import_node_fs53.existsSync)((0, import_node_path52.join)(process.cwd(), marker))) return process.cwd();
+  if ((0, import_node_fs54.existsSync)((0, import_node_path53.join)(fromPkg, marker))) return fromPkg;
+  if ((0, import_node_fs54.existsSync)((0, import_node_path53.join)(process.cwd(), marker))) return process.cwd();
   return null;
 }
 registerQueryCommands(program2);
@@ -53773,6 +54502,7 @@ registerTrainCommandsAndInventory(program2);
 registerFleetLockstepEnforce(program2);
 registerDeployCommands(program2);
 registerSuiteCommands(program2);
+registerPackagesCommands(program2);
 registerDiscoveryCommands(program2);
 registerExplainCommand(program2);
 registerPrLifecycleCommands(program2);
@@ -53888,10 +54618,10 @@ access.command("audit").description("audit collaborator roles + train-branch pus
     targets = resolution.targets;
   }
   const derivedMatrix = registryProjects ? accessMatrixFromProjects(registryProjects) : {};
-  const fileMatrix = (0, import_node_fs53.existsSync)("access-matrix.json") ? loadAccessMatrix((0, import_node_fs53.readFileSync)("access-matrix.json", "utf8")) : {};
+  const fileMatrix = (0, import_node_fs54.existsSync)("access-matrix.json") ? loadAccessMatrix((0, import_node_fs54.readFileSync)("access-matrix.json", "utf8")) : {};
   const matrix = mergeAccessMatrix(fileMatrix, derivedMatrix);
   const dataAccess = registryProjects ? dataAccessContractsFromProjects(registryProjects) : { consumers: {} };
-  const sanctioned = (0, import_node_fs53.existsSync)("access-matrix.json") ? loadSanctionedAdmins((0, import_node_fs53.readFileSync)("access-matrix.json", "utf8")) : {};
+  const sanctioned = (0, import_node_fs54.existsSync)("access-matrix.json") ? loadSanctionedAdmins((0, import_node_fs54.readFileSync)("access-matrix.json", "utf8")) : {};
   const report = await auditOrgAccess(targets, deps, matrix, dataAccess, sanctioned);
   console.log(o.json ? JSON.stringify(report, null, 2) : renderAccessReport(report));
   if (!report.ok) process.exitCode = 1;
@@ -53922,16 +54652,16 @@ function directoryBytes(path2) {
   let total = 0;
   let entries;
   try {
-    entries = (0, import_node_fs53.readdirSync)(path2, { withFileTypes: true });
+    entries = (0, import_node_fs54.readdirSync)(path2, { withFileTypes: true });
   } catch {
     return 0;
   }
   for (const entry of entries) {
-    const child2 = (0, import_node_path52.join)(path2, entry.name);
+    const child2 = (0, import_node_path53.join)(path2, entry.name);
     if (entry.isDirectory()) total += directoryBytes(child2);
     else {
       try {
-        total += (0, import_node_fs53.statSync)(child2).size;
+        total += (0, import_node_fs54.statSync)(child2).size;
       } catch {
       }
     }
@@ -53939,25 +54669,25 @@ function directoryBytes(path2) {
   return total;
 }
 function listDirEntries(dir) {
-  return (0, import_node_fs53.readdirSync)(dir, { withFileTypes: true }).map((d) => ({ name: d.name, isDirectory: d.isDirectory() }));
+  return (0, import_node_fs54.readdirSync)(dir, { withFileTypes: true }).map((d) => ({ name: d.name, isDirectory: d.isDirectory() }));
 }
 function readInstalledPluginRefs(configRoot) {
   const p = installedPluginsPathForConfig(configRoot);
-  if (!(0, import_node_fs53.existsSync)(p)) return [];
+  if (!(0, import_node_fs54.existsSync)(p)) return [];
   try {
-    return installedPluginPaths((0, import_node_fs53.readFileSync)(p, "utf8"));
+    return installedPluginPaths((0, import_node_fs54.readFileSync)(p, "utf8"));
   } catch {
     return null;
   }
 }
 function pluginCacheFsDeps(configRoot, dirBytes) {
   return {
-    exists: (p) => (0, import_node_fs53.existsSync)(p),
-    listVersionDirs: (root) => (0, import_node_fs53.readdirSync)(root, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name),
+    exists: (p) => (0, import_node_fs54.existsSync)(p),
+    listVersionDirs: (root) => (0, import_node_fs54.readdirSync)(root, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name),
     dirBytes,
-    listStagingDirs: (root) => (0, import_node_fs53.readdirSync)(root, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => {
+    listStagingDirs: (root) => (0, import_node_fs54.readdirSync)(root, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => {
       try {
-        return { name: d.name, mtimeMs: newestMtimeMs((0, import_node_path52.join)(root, d.name), listDirEntries, (p) => (0, import_node_fs53.statSync)(p).mtimeMs) };
+        return { name: d.name, mtimeMs: newestMtimeMs((0, import_node_path53.join)(root, d.name), listDirEntries, (p) => (0, import_node_fs54.statSync)(p).mtimeMs) };
       } catch {
         return { name: d.name, mtimeMs: Date.now() };
       }
@@ -53971,10 +54701,10 @@ function stagingApplyFsGuard(configRoot) {
   return {
     referencedPaths: () => readInstalledPluginRefs(configRoot),
     mtimeMs: (name) => {
-      const p = (0, import_node_path52.join)(stagingRoot, name);
-      if (!(0, import_node_fs53.existsSync)(p)) return null;
+      const p = (0, import_node_path53.join)(stagingRoot, name);
+      if (!(0, import_node_fs54.existsSync)(p)) return null;
       try {
-        return newestMtimeMs(p, listDirEntries, (q) => (0, import_node_fs53.statSync)(q).mtimeMs);
+        return newestMtimeMs(p, listDirEntries, (q) => (0, import_node_fs54.statSync)(q).mtimeMs);
       } catch {
         return null;
       }
@@ -53994,13 +54724,13 @@ program2.command("plugin-prune").description(`prune stale cached MMI plugin vers
     return;
   }
   const plan = buildPluginCachePlan(
-    (0, import_node_os23.homedir)(),
+    (0, import_node_os24.homedir)(),
     running,
     pluginCacheFsDeps(configRoot, directoryBytes),
     { withBytes: true, configRoot, includeStaging: surface !== "codex" }
   );
   const anythingToDelete = plan.prune.length > 0 || plan.staging.length > 0;
-  const result = o.apply && anythingToDelete ? applyPluginCachePlan(plan, (p) => (0, import_node_fs53.rmSync)(p, { recursive: true, force: true }), stagingApplyFsGuard(configRoot)) : void 0;
+  const result = o.apply && anythingToDelete ? applyPluginCachePlan(plan, (p) => (0, import_node_fs54.rmSync)(p, { recursive: true, force: true }), stagingApplyFsGuard(configRoot)) : void 0;
   const warnings = plan.prune.length > 0 ? [CONCURRENT_SESSION_WARNING] : [];
   if (o.json) console.log(JSON.stringify({ ...plan, warnings, applied: result ?? null }));
   else console.log(renderPluginCachePlan(plan, result));