@event4u/agent-config 17.3.0 → 17.4.0

package/dist/cli-delegate/{upgrade_unattended-VVL6JLSX.js → upgrade_unattended-QCWOKTUN.js}

@@ -24,46 +24,24 @@ import {
 import "./chunk-J55WI3RR.js";
 
 // src/scripts/_cli/upgrade_unattended.ts
-import * as fs from "node:fs";
-import * as path from "node:path";
+import * as crypto from "node:crypto";
+import * as fs2 from "node:fs";
+import * as os from "node:os";
+import * as path2 from "node:path";
 import { spawnSync } from "node:child_process";
 import process from "node:process";
 
+// src/scripts/_lib/sigstore_provenance.ts
+import { createHash } from "node:crypto";
+import * as fs from "node:fs";
+import * as path from "node:path";
+
 // src/scripts/_lib/provenance_verify.ts
 var EXPECTED_WORKFLOW_REF = ".github/workflows/publish-npm.yml";
 var EXPECTED_REPOSITORY = "https://github.com/event4u-app/agent-config";
 function asRecord(v) {
   return v !== null && typeof v === "object" && !Array.isArray(v) ? v : null;
 }
-function decode_payload(doc) {
-  const list = asRecord(doc)?.["attestations"];
-  if (!Array.isArray(list) || list.length === 0) return null;
-  for (const entry of list) {
-    const payload = asRecord(asRecord(asRecord(entry)?.["bundle"])?.["dsseEnvelope"])?.["payload"];
-    if (typeof payload !== "string" || payload === "") continue;
-    try {
-      const parsed = JSON.parse(Buffer.from(payload, "base64").toString("utf8"));
-      const rec = asRecord(parsed);
-      if (rec !== null) return rec;
-    } catch {
-    }
-  }
-  return null;
-}
-function external_workflow(doc) {
-  const payload = decode_payload(doc);
-  if (payload === null) return null;
-  const predicate = asRecord(payload["predicate"]);
-  const external = asRecord(asRecord(predicate?.["buildDefinition"])?.["externalParameters"]);
-  return asRecord(external?.["workflow"]);
-}
-function attestation_workflow_ref(doc) {
-  const path_value = external_workflow(doc)?.["path"];
-  return typeof path_value === "string" && path_value !== "" ? path_value : null;
-}
-function provenance_matches_publish(doc) {
-  return payload_names_publish(decode_payload(doc));
-}
 function payload_names_publish(payload) {
   const predicate = asRecord(payload?.["predicate"]);
   const workflow = asRecord(asRecord(asRecord(predicate?.["buildDefinition"])?.["externalParameters"])?.["workflow"]);
@@ -72,109 +50,124 @@ function payload_names_publish(payload) {
   if (typeof repo !== "string" || repo === "") return false;
   return repo.replace(/\.git$/, "").replace(/\/$/, "") === EXPECTED_REPOSITORY;
 }
-function san_names_workflow(san) {
-  return san.split(/,\s*/).some((e) => e.startsWith(`URI:${SAN_WORKFLOW_MARKER}@`));
-}
-var SAN_WORKFLOW_MARKER = `${EXPECTED_REPOSITORY}/${EXPECTED_WORKFLOW_REF}`;
-function dssePae(payloadType, payload) {
-  const type = Buffer.from(payloadType, "utf8");
-  return Buffer.concat([
-    Buffer.from(`DSSEv1 ${String(type.length)} `, "utf8"),
-    type,
-    Buffer.from(` ${String(payload.length)} `, "utf8"),
-    payload
-  ]);
-}
-function readEnvelope(entry) {
-  const bundle = asRecord(asRecord(entry)?.["bundle"]);
-  const dsse = asRecord(bundle?.["dsseEnvelope"]);
-  if (dsse === null) return null;
-  const payloadB64 = dsse["payload"];
-  const payloadType = dsse["payloadType"];
-  const sigs = dsse["signatures"];
-  if (typeof payloadB64 !== "string" || typeof payloadType !== "string" || !Array.isArray(sigs) || sigs.length === 0) return null;
-  const sigB64 = asRecord(sigs[0])?.["sig"];
-  if (typeof sigB64 !== "string" || sigB64 === "") return null;
-  const material = asRecord(bundle?.["verificationMaterial"]);
-  const single = asRecord(material?.["certificate"])?.["rawBytes"];
-  const chain = asRecord(material?.["x509CertificateChain"])?.["certificates"];
-  const first = Array.isArray(chain) ? asRecord(chain[0])?.["rawBytes"] : void 0;
-  const certB64 = typeof single === "string" ? single : typeof first === "string" ? first : null;
-  if (certB64 === null || certB64 === "") return null;
-  return {
-    payloadType,
-    payload: Buffer.from(payloadB64, "base64"),
-    sig: Buffer.from(sigB64, "base64"),
-    certDer: Buffer.from(certB64, "base64")
-  };
+
+// src/scripts/_lib/sigstore_provenance.ts
+var SLSA_PROVENANCE_V1 = "https://slsa.dev/provenance/v1";
+var NPM_PUBLISH_V01 = "https://github.com/npm/attestation/tree/main/specs/publish/v0.1";
+var GITHUB_OIDC_ISSUER = "https://token.actions.githubusercontent.com";
+var PACKAGE_PURL_BASE = "pkg:npm/%40event4u/agent-config";
+function asRecord2(v) {
+  return v !== null && typeof v === "object" && !Array.isArray(v) ? v : null;
+}
+function escapeRegExp(s) {
+  return s.replace(/[.*+?^${}()|[\]\\/]/g, "\\$&");
+}
+function expectedSan(version) {
+  return new RegExp(`^${escapeRegExp(`${EXPECTED_REPOSITORY}/${EXPECTED_WORKFLOW_REF}@refs/tags/${version}`)}$`);
+}
+function readTrustFiles(packageRoot = resolvePackageRoot(import.meta.url)) {
+  const dir = path.join(packageRoot, "src", "config", "sigstore");
+  try {
+    const manifest = JSON.parse(fs.readFileSync(path.join(dir, "trust-material.json"), "utf-8"));
+    const read = (name) => {
+      const bytes = fs.readFileSync(path.join(dir, name));
+      const want = manifest.files?.[name];
+      const got = createHash("sha256").update(bytes).digest("hex");
+      if (want !== got) throw new Error(`${name} has sha256 ${got}, the recorded one is ${String(want)}`);
+      return JSON.parse(bytes.toString("utf-8"));
+    };
+    return { trustedRoot: read("trusted_root.json"), npmKeys: read("npm_keys.json") };
+  } catch (err) {
+    return `the pinned sigstore trust material is unusable: ${err instanceof Error ? err.message : String(err)}`;
+  }
+}
+function subjectMatches(payload, version, sha512Hex) {
+  const subjects = payload?.["subject"];
+  if (!Array.isArray(subjects) || subjects.length !== 1) return "it does not name exactly one subject";
+  const subject = asRecord2(subjects[0]);
+  if (subject?.["name"] !== `${PACKAGE_PURL_BASE}@${version}`) return `its subject is ${String(subject?.["name"])}, not ${version}`;
+  const digest = asRecord2(subject["digest"])?.["sha512"];
+  if (typeof digest !== "string" || digest.toLowerCase() !== sha512Hex.toLowerCase()) {
+    return "its subject digest does not match the tarball about to be installed";
+  }
+  return null;
 }
-async function verify_attestation_signature(doc) {
-  const list = asRecord(doc)?.["attestations"];
-  if (!Array.isArray(list) || list.length === 0) return "the attestation bundle carries no attestations";
-  const crypto = await import("node:crypto");
-  let lastReason = "no attestation carried a readable DSSE envelope";
+async function verify_release_provenance(release, trust = readTrustFiles()) {
+  if (typeof trust === "string") return trust;
+  const list = asRecord2(release.attestations)?.["attestations"];
+  if (!Array.isArray(list)) return "the attestation document carries no attestations";
+  const byType = /* @__PURE__ */ new Map();
   for (const entry of list) {
-    const env = readEnvelope(entry);
-    if (env === null) continue;
-    let cert;
-    try {
-      cert = new crypto.X509Certificate(env.certDer);
-    } catch {
-      lastReason = "the signing certificate could not be parsed";
-      continue;
-    }
-    const san = cert.subjectAltName ?? "";
-    if (!san_names_workflow(san)) {
-      lastReason = `the signing certificate names ${san === "" ? "no identity" : san}, not ${SAN_WORKFLOW_MARKER}`;
-      continue;
-    }
-    let ok = false;
-    try {
-      ok = crypto.verify(null, dssePae(env.payloadType, env.payload), cert.publicKey, env.sig);
-    } catch {
-      ok = false;
-    }
-    if (!ok) {
-      lastReason = "the DSSE signature does not verify against the certificate in the bundle";
-      continue;
+    const type = asRecord2(entry)?.["predicateType"];
+    if (typeof type === "string" && !byType.has(type)) byType.set(type, asRecord2(entry)?.["bundle"]);
+  }
+  for (const type of [SLSA_PROVENANCE_V1, NPM_PUBLISH_V01]) {
+    if (!byType.has(type)) return `the release carries no ${type} attestation`;
+  }
+  const { Verifier, toSignedEntity, toTrustMaterial } = await import("./dist-25AZAHOP.js");
+  const { bundleFromJSON } = await import("./dist-P7MFPMF3.js");
+  const { PublicKey, TrustedRoot } = await import("./dist-XAS5ZLQB.js");
+  let material;
+  try {
+    const keys = {};
+    const listed = asRecord2(trust.npmKeys)?.["keys"];
+    for (const k of Array.isArray(listed) ? listed : []) {
+      const key = asRecord2(k);
+      if (key?.["keyUsage"] === "npm:attestations" && typeof key["keyId"] === "string") {
+        keys[key["keyId"]] = PublicKey.fromJSON(key["publicKey"]);
+      }
     }
-    let verified = null;
+    material = toTrustMaterial(TrustedRoot.fromJSON(trust.trustedRoot), keys);
+  } catch (err) {
+    return `the pinned sigstore trust material could not be loaded: ${err instanceof Error ? err.message : String(err)}`;
+  }
+  for (const type of [SLSA_PROVENANCE_V1, NPM_PUBLISH_V01]) {
+    let payload;
     try {
-      verified = asRecord(JSON.parse(env.payload.toString("utf8")));
-    } catch {
-      verified = null;
+      const bundle = bundleFromJSON(byType.get(type));
+      const verifier = new Verifier(material, { tlogThreshold: 1, ctlogThreshold: 1, timestampThreshold: 1 });
+      const policy = type === SLSA_PROVENANCE_V1 ? { subjectAlternativeName: expectedSan(release.version), extensions: { issuer: GITHUB_OIDC_ISSUER } } : void 0;
+      verifier.verify(toSignedEntity(bundle), policy);
+      if (bundle.content.$case !== "dsseEnvelope") return `the ${type} attestation is not a DSSE envelope`;
+      payload = asRecord2(JSON.parse(bundle.content.dsseEnvelope.payload.toString("utf-8")));
+    } catch (err) {
+      const code = asRecord2(err)?.["code"];
+      return `the ${type} attestation does not verify${typeof code === "string" ? ` (${code})` : ""}: ${err instanceof Error ? err.message : String(err)}`;
     }
-    if (!payload_names_publish(verified)) {
-      lastReason = "the signed payload does not name this package's publish workflow";
-      continue;
+    if (payload?.["predicateType"] !== type) return `the ${type} attestation's statement names another predicate type`;
+    const subject = subjectMatches(payload, release.version, release.tarballSha512Hex);
+    if (subject !== null) return `the ${type} attestation is not for this tarball: ${subject}`;
+    if (type === SLSA_PROVENANCE_V1 && !payload_names_publish(payload)) {
+      return `the signed provenance does not name ${EXPECTED_WORKFLOW_REF} in ${EXPECTED_REPOSITORY}`;
     }
-    return null;
   }
-  return lastReason;
+  return null;
 }
 
 // src/scripts/_lib/unattended_gates.ts
 var UNATTENDED_MIN_RELEASE_AGE_HOURS = 72;
-function asRecord2(v) {
+function asRecord3(v) {
   return v !== null && typeof v === "object" && !Array.isArray(v) ? v : null;
 }
 function read_candidate(packument) {
-  const doc = asRecord2(packument);
-  const version = asRecord2(doc?.["dist-tags"])?.["latest"];
+  const doc = asRecord3(packument);
+  const version = asRecord3(doc?.["dist-tags"])?.["latest"];
   if (typeof version !== "string" || version === "") return null;
-  const manifest = asRecord2(asRecord2(doc?.["versions"])?.[version]);
+  const manifest = asRecord3(asRecord3(doc?.["versions"])?.[version]);
   if (manifest === null) return null;
-  const published = asRecord2(doc?.["time"])?.[version];
-  const attestations = asRecord2(asRecord2(manifest["dist"])?.["attestations"]);
-  const predicate = asRecord2(attestations?.["provenance"])?.["predicateType"];
+  const published = asRecord3(doc?.["time"])?.[version];
+  const attestations = asRecord3(asRecord3(manifest["dist"])?.["attestations"]);
+  const predicate = asRecord3(attestations?.["provenance"])?.["predicateType"];
   return {
     version,
     publishedAt: typeof published === "string" ? published : null,
     deprecated: manifest["deprecated"],
     engines: manifest["engines"],
     provenance: typeof predicate === "string" && predicate.startsWith("https://slsa.dev/provenance/"),
-    impactMap: asRecord2(manifest["agentConfig"])?.["impact"] ?? null,
-    attestationsUrl: typeof attestations?.["url"] === "string" ? attestations["url"] : null
+    impactMap: asRecord3(manifest["agentConfig"])?.["impact"] ?? null,
+    attestationsUrl: typeof attestations?.["url"] === "string" ? attestations["url"] : null,
+    tarballUrl: typeof asRecord3(manifest["dist"])?.["tarball"] === "string" ? asRecord3(manifest["dist"])?.["tarball"] : null,
+    integrity: typeof asRecord3(manifest["dist"])?.["integrity"] === "string" ? asRecord3(manifest["dist"])?.["integrity"] : null
   };
 }
 function unattended_decision(input) {
@@ -214,7 +207,7 @@ function say(sink, line) {
 }
 function read_skips(skipPath) {
   try {
-    const data = JSON.parse(fs.readFileSync(skipPath, "utf-8"));
+    const data = JSON.parse(fs2.readFileSync(skipPath, "utf-8"));
     const list = data?.skip;
     return Array.isArray(list) ? list.filter((v) => typeof v === "string") : [];
   } catch {
@@ -224,12 +217,12 @@ function read_skips(skipPath) {
 function record_skip(skipPath, version) {
   const skips = read_skips(skipPath);
   if (!skips.includes(version)) skips.push(version);
-  fs.mkdirSync(path.dirname(skipPath), { recursive: true });
-  fs.writeFileSync(skipPath, JSON.stringify({ skip: skips.sort() }, null, 2) + "\n", "utf-8");
+  fs2.mkdirSync(path2.dirname(skipPath), { recursive: true });
+  fs2.writeFileSync(skipPath, JSON.stringify({ skip: skips.sort() }, null, 2) + "\n", "utf-8");
 }
 function read_text(p) {
   try {
-    return fs.readFileSync(p, "utf-8");
+    return fs2.readFileSync(p, "utf-8");
   } catch {
     return null;
   }
@@ -238,15 +231,15 @@ function acquire_lock(deps) {
   const record = { pid: deps.pid, started_at: deps.now().toISOString(), ttl_ms: LOCK_TTL_MS };
   const mine = `${deps.lockPath}.${deps.pid}.${process.hrtime.bigint()}`;
   try {
-    fs.mkdirSync(path.dirname(deps.lockPath), { recursive: true });
-    fs.writeFileSync(mine, JSON.stringify(record) + "\n", { flag: "wx" });
+    fs2.mkdirSync(path2.dirname(deps.lockPath), { recursive: true });
+    fs2.writeFileSync(mine, JSON.stringify(record) + "\n", { flag: "wx" });
   } catch (exc) {
     return `cannot write the lock: ${String(exc)}`;
   }
   try {
     for (let attempt = 0; attempt < 2; attempt += 1) {
       try {
-        fs.linkSync(mine, deps.lockPath);
+        fs2.linkSync(mine, deps.lockPath);
         return null;
       } catch (exc) {
         if (exc.code !== "EEXIST") return `cannot write the lock: ${String(exc)}`;
@@ -264,35 +257,35 @@ function acquire_lock(deps) {
       }
       const tomb = `${mine}.stale`;
       try {
-        fs.renameSync(deps.lockPath, tomb);
+        fs2.renameSync(deps.lockPath, tomb);
       } catch {
         continue;
       }
       if (read_text(tomb) !== judged) {
         try {
-          fs.linkSync(tomb, deps.lockPath);
+          fs2.linkSync(tomb, deps.lockPath);
         } catch {
         }
-        fs.rmSync(tomb, { force: true });
+        fs2.rmSync(tomb, { force: true });
         return "another unattended upgrade took the lock over first";
       }
-      fs.rmSync(tomb, { force: true });
+      fs2.rmSync(tomb, { force: true });
     }
     return "the lock could not be taken";
   } finally {
-    fs.rmSync(mine, { force: true });
+    fs2.rmSync(mine, { force: true });
   }
 }
 function release_lock(deps) {
   try {
-    const held = JSON.parse(fs.readFileSync(deps.lockPath, "utf-8"));
-    if (held.pid === deps.pid) fs.unlinkSync(deps.lockPath);
+    const held = JSON.parse(fs2.readFileSync(deps.lockPath, "utf-8"));
+    if (held.pid === deps.pid) fs2.unlinkSync(deps.lockPath);
   } catch {
   }
 }
-function install_steps(version, deps) {
+function install_steps(spec, deps) {
   return [
-    ["npm", "install", "-g", `${PACKAGE_NAME}@${version}`],
+    ["npm", "install", "-g", spec],
     [deps.agentConfigBin, "global", "--no-ui"],
     ...deps.globalSettings.map((target) => [deps.agentConfigBin, "settings:sync", "--path", target])
   ];
@@ -307,7 +300,7 @@ function run_steps(steps, deps, honourSignal = true) {
   return { ok: true };
 }
 function restore(previous, deps) {
-  const back = run_steps(install_steps(previous, deps).slice(0, 2), deps, false);
+  const back = run_steps(install_steps(`${PACKAGE_NAME}@${previous}`, deps).slice(0, 2), deps, false);
   const lock = deps.readInstalled();
   const binary = deps.readBinary();
   if (back.ok && lock === previous && binary === previous) {
@@ -334,41 +327,58 @@ async function decide(installed, deps) {
   });
   if (!decision.install) return { refused: [...decision.reasons] };
   const provenance = await deps.verifyProvenance(candidate);
-  if (provenance !== null) return { refused: [provenance] };
-  return { candidate };
-}
-async function verify_provenance_default(candidate, fetch_impl = fetch, timeoutMs = 1e4) {
-  if (candidate.attestationsUrl === null) {
-    return `${candidate.version} carries no attestation bundle to verify`;
+  if (!provenance.ok) return { refused: [provenance.reason] };
+  return { candidate, tarball: provenance.tarball };
+}
+var MAX_TARBALL_BYTES = 64 * 1024 * 1024;
+async function verify_provenance_default(candidate, fetch_impl = fetch, timeoutMs = 6e4, verify = (r) => verify_release_provenance(r)) {
+  const v = candidate.version;
+  const registry = new URL(PACKUMENT_URL).origin;
+  const refuse = (reason2) => ({ ok: false, reason: `${v}: ${reason2}` });
+  for (const [what, url] of [
+    ["attestation bundle", candidate.attestationsUrl],
+    ["tarball", candidate.tarballUrl]
+  ]) {
+    if (url === null) return refuse(`the registry names no ${what} to verify`);
+    let origin = "";
+    try {
+      origin = new URL(url).origin;
+    } catch {
+    }
+    if (origin !== registry) return refuse(`the ${what} url is not on ${registry}`);
   }
-  let origin;
+  const integrity = /^sha512-([A-Za-z0-9+/=]+)$/.exec(candidate.integrity ?? "");
+  if (integrity === null) return refuse("the registry records no sha512 integrity for the tarball");
+  const get = async (url) => {
+    const resp = await fetch_impl(url, { signal: AbortSignal.timeout(timeoutMs), redirect: "error" });
+    if (!resp.ok) throw new Error(`HTTP ${resp.status}`);
+    return resp;
+  };
+  let attestations;
+  let bytes;
   try {
-    origin = new URL(candidate.attestationsUrl).origin;
-  } catch {
-    origin = "";
+    attestations = await (await get(candidate.attestationsUrl)).json();
+    const resp = await get(candidate.tarballUrl);
+    if (Number(resp.headers.get("content-length") ?? 0) > MAX_TARBALL_BYTES) return refuse("the tarball is larger than allowed");
+    bytes = Buffer.from(await resp.arrayBuffer());
+  } catch (err) {
+    return refuse(`download failed: ${err instanceof Error ? err.message : String(err)}`);
   }
-  if (origin !== new URL(PACKUMENT_URL).origin) {
-    return `${candidate.version}: attestation url is not on ${new URL(PACKUMENT_URL).origin}`;
+  if (bytes.length > MAX_TARBALL_BYTES) return refuse("the tarball is larger than allowed");
+  const digest = crypto.createHash("sha512").update(bytes).digest();
+  if (!digest.equals(Buffer.from(integrity[1], "base64"))) {
+    return refuse("the downloaded tarball does not match the integrity the registry records");
   }
-  let doc;
+  const reason = await verify({ version: v, tarballSha512Hex: digest.toString("hex"), attestations });
+  if (reason !== null) return refuse(reason);
   try {
-    const resp = await fetch_impl(candidate.attestationsUrl, {
-      signal: AbortSignal.timeout(timeoutMs),
-      headers: { accept: "application/json" },
-      redirect: "error"
-    });
-    if (!resp.ok) return `attestation fetch failed: HTTP ${resp.status}`;
-    doc = await resp.json();
+    const dir = fs2.mkdtempSync(path2.join(os.tmpdir(), "agent-config-upgrade-"));
+    const tarball = path2.join(dir, `agent-config-${v}.tgz`);
+    fs2.writeFileSync(tarball, bytes, { mode: 384, flag: "wx" });
+    return { ok: true, tarball };
   } catch (err) {
-    return `attestation fetch failed: ${err instanceof Error ? err.message : String(err)}`;
-  }
-  if (!provenance_matches_publish(doc)) {
-    const named = attestation_workflow_ref(doc);
-    return named === null ? `${candidate.version} has no readable provenance workflow in its attestation` : `${candidate.version} was built by ${named}, not ${EXPECTED_WORKFLOW_REF}`;
+    return refuse(`cannot write the verified tarball: ${err instanceof Error ? err.message : String(err)}`);
   }
-  const signature = await verify_attestation_signature(doc);
-  if (signature !== null) return `${candidate.version}: ${signature}`;
-  return null;
 }
 function quiet_context(deps) {
   if (deps.env.ci) return "suppressed: CI";
@@ -392,14 +402,16 @@ async function run_unattended(deps) {
     say(deps.err, `${PREFIX}: not installing \u2014 ${locked}.`);
     return EXIT_REFUSED;
   }
+  let verified = null;
   try {
     const verdict = await decide(previous, deps);
     if ("refused" in verdict) {
       say(deps.out, `\u2139\uFE0F  ${PREFIX}: not installing (installed: ${previous}) \u2014 ${verdict.refused.join("; ")}.`);
       return EXIT_REFUSED;
     }
+    verified = verdict.tarball;
     const target = verdict.candidate.version;
-    const steps = install_steps(target, deps);
+    const steps = install_steps(verified, deps);
     if (deps.activationBlocked !== null) {
       const how = deps.dryRun ? "dry run: a real run would not install" : "not installing";
       say(deps.out, `\u2139\uFE0F  ${PREFIX}: every gate passed for ${target}, but ${how} \u2014 ${deps.activationBlocked}.`);
@@ -417,9 +429,10 @@ async function run_unattended(deps) {
     }
     const what = `${ran.cmd.join(" ")} (exit ${ran.result.rc})`;
     if (/\bEACCES\b/.test(ran.result.stderr)) {
+      const manual = ran.cmd === steps[0] ? ["npm", "install", "-g", `${PACKAGE_NAME}@${target}`] : ran.cmd;
       say(
         deps.err,
-        `\u274C  ${PREFIX}: permission denied on ${what}. agent-config never runs sudo; run this yourself with the right permissions: ${ran.cmd.join(" ")}`
+        `\u274C  ${PREFIX}: permission denied on ${what}. agent-config never runs sudo; run this yourself with the right permissions: ${manual.join(" ")}`
       );
       const untouched = ran.cmd === steps[0] && deps.readInstalled() === previous && deps.readBinary() === previous;
       if (untouched) return 1;
@@ -428,6 +441,7 @@ async function run_unattended(deps) {
     say(deps.err, `\u274C  ${PREFIX}: step failed: ${what} \u2014 restoring ${previous}.`);
     return restore(previous, deps);
   } finally {
+    if (verified !== null) fs2.rmSync(path2.dirname(verified), { recursive: true, force: true });
     release_lock(deps);
   }
 }
@@ -467,8 +481,8 @@ function skip_version(version, out) {
   return 0;
 }
 async function run_unattended_default(options) {
-  const globalSettings = path.join(event4u_root(), "settings", ".agent-settings.yml");
-  const packageJson = path.join(resolvePackageRoot(import.meta.url), "package.json");
+  const globalSettings = path2.join(event4u_root(), "settings", ".agent-settings.yml");
+  const packageJson = path2.join(resolvePackageRoot(import.meta.url), "package.json");
   let terminated = false;
   const onTerm = () => {
     terminated = true;
@@ -484,7 +498,7 @@ function run_unattended_wired(options, globalSettings, packageJson, interrupted)
   return run_unattended({
     readBinary: () => {
       try {
-        const v = JSON.parse(fs.readFileSync(packageJson, "utf-8")).version;
+        const v = JSON.parse(fs2.readFileSync(packageJson, "utf-8")).version;
         return typeof v === "string" ? v : "";
       } catch {
         return "";
@@ -500,7 +514,7 @@ function run_unattended_wired(options, globalSettings, packageJson, interrupted)
     },
     origin: running_origin(),
     agentConfigBin: options.agentConfigBin,
-    globalSettings: fs.existsSync(globalSettings) ? [globalSettings] : [],
+    globalSettings: fs2.existsSync(globalSettings) ? [globalSettings] : [],
     lockPath: write_target(LOCK_FILE),
     skipPath: write_target(SKIP_FILE),
     env: {
@@ -523,6 +537,7 @@ export {
   EXIT_RESTORE_FAILED,
   LOCK_FILE,
   LOCK_TTL_MS,
+  MAX_TARBALL_BYTES,
   PACKAGE_NAME,
   PACKUMENT_URL,
   SKIP_FILE,

package/dist/discovery/deprecation-report.md

@@ -1,6 +1,6 @@
 # Discovery — Deprecation Report
 
-- Generated: `2026-10-24T05:31:43Z`
+- Generated: `2026-10-24T10:59:12Z`
 - Deprecated artefacts: **0**
 
 _None. Tree is clean._

package/dist/discovery/discovery-manifest.json

@@ -9206,7 +9206,7 @@
     },
     {
       "category": "skill",
-      "checksum": "sha256:8453a22d61bc6a6d3f1edf4b1fe8691a1964a7c0fccc64db508cfdf5a96da27a",
+      "checksum": "sha256:f5dc56a475d0180931625a4c590af8b45dc365593fdd44ec992284d4d7b0d6c8",
       "install": {
         "default": true,
         "removable": false
@@ -15120,7 +15120,7 @@
       "workspaces": []
     }
   ],
-  "checksum": "sha256:55b3f948c10233f9fa0ddc32b6ff8b6701ea822011e0448a32228a574541cf3e",
+  "checksum": "sha256:03d3bf776b1cd4eb516f50f873eb435611b9d8ab590337913eb19e786224d144",
   "deprecations": [
     {
       "key": "tier",
@@ -15269,7 +15269,7 @@
       "reason": "scaffold template for ticket-bundle tickets (ADR-101); carries no runtime frontmatter — emit-tickets fills it in per ticket"
     }
   ],
-  "generated_at": "2026-10-24T05:31:43Z",
+  "generated_at": "2026-10-24T10:59:12Z",
   "packs": [
     {
       "artefact_count": 130,

package/dist/discovery/discovery-manifest.json.sha256

@@ -1 +1 @@
-9aa654312e6184bbe25cd1777fff6eaedfb4f3c85d543e5cffb780fca2553bae  discovery-manifest.json
+1388c41a068bccdb4c8ad314e25db5de1c2ba4e5bd68ba9ffa5a0f1cf5755318  discovery-manifest.json

package/dist/discovery/discovery-manifest.summary.md

@@ -1,6 +1,6 @@
 # Discovery Manifest — Summary
 
-- Generated: `2026-10-24T05:31:43Z`
+- Generated: `2026-10-24T10:59:12Z`
 - Scanner: `de0a22b4ac4c`
 - Artefacts: **637**
 - Unassigned: **0**

package/dist/discovery/dormancy-report.md

@@ -1,6 +1,6 @@
 # Discovery — Dormancy Report
 
-- Generated: `2026-10-24T05:31:43Z`
+- Generated: `2026-10-24T10:59:12Z`
 - Window: **6 months** without a commit
 
 > Dormancy triggers **review, never auto-deprecation**

package/dist/discovery/orphan-report.md

@@ -1,6 +1,6 @@
 # Discovery — Orphan Report
 
-- Generated: `2026-10-24T05:31:43Z`
+- Generated: `2026-10-24T10:59:12Z`
 - Orphan artefacts: **0**
 
 > An orphan is an artefact whose declared pack has no other members.

package/dist/discovery/packs.json

@@ -1,6 +1,6 @@
 {
-  "checksum": "sha256:55b3f948c10233f9fa0ddc32b6ff8b6701ea822011e0448a32228a574541cf3e",
-  "generated_at": "2026-10-24T05:31:43Z",
+  "checksum": "sha256:03d3bf776b1cd4eb516f50f873eb435611b9d8ab590337913eb19e786224d144",
+  "generated_at": "2026-10-24T10:59:12Z",
   "packs": [
     {
       "always_on": false,

package/dist/discovery/trust-report.md

@@ -1,6 +1,6 @@
 # Discovery — Trust Report
 
-- Generated: `2026-10-24T05:31:43Z`
+- Generated: `2026-10-24T10:59:12Z`
 - Workspaces tracked: **10**
 - Human-review-required artefacts: **3**
 

package/dist/discovery/workspaces.json

@@ -1,6 +1,6 @@
 {
-  "checksum": "sha256:55b3f948c10233f9fa0ddc32b6ff8b6701ea822011e0448a32228a574541cf3e",
-  "generated_at": "2026-10-24T05:31:43Z",
+  "checksum": "sha256:03d3bf776b1cd4eb516f50f873eb435611b9d8ab590337913eb19e786224d144",
+  "generated_at": "2026-10-24T10:59:12Z",
   "scanner_version": "de0a22b4ac4c",
   "workspaces": [
     {