@codyswann/lisa 4.74.7 → 4.74.9

package/all/copy-overwrite/scripts/lib/npm-update-cancel-origin.mjs

@@ -45,7 +45,7 @@ export function completeCheckpoints(comments) {
   );
   const digests = new Set();
   for (const comment of comments) {
-    const match = /^\[lisa-npm-checkpoint\] v1 ([a-f0-9]{64}) complete\n/.exec(
+    const match = /^\[lisa-npm-checkpoint\] \S+ ([a-f0-9]{64}) complete\n/.exec(
       comment.body ?? ""
     );
     if (match) digests.add(match[1]);
@@ -113,7 +113,9 @@ export function assertOriginTransport(
   required(chronology, "invalid original transport chronology");
   const { start, end } = chronology;
   const selected = comments.filter(comment =>
-    comment.body?.startsWith(`[lisa-npm-checkpoint] v1 ${digest} `)
+    new RegExp(`^\\[lisa-npm-checkpoint\\] v[12] ${digest} `).test(
+      comment.body ?? ""
+    )
   );
   required(selected.length > 0, "original transport is missing");
   for (const comment of selected) {

package/all/copy-overwrite/scripts/lib/npm-update-checkpoint-codec.mjs

@@ -0,0 +1,141 @@
+// This file is managed by Lisa and IS replaced on each `lisa` run.
+// Do not edit directly — durable changes belong upstream in Lisa.
+
+/**
+ * @file npm-update-checkpoint-codec.mjs
+ * @description Reduce serial public writes without extending signed authorization freshness.
+ * @module npm-updater
+ */
+import { TextDecoder } from "node:util";
+import { deflateSync, inflateSync } from "node:zlib";
+import { canonicalJson } from "../lisa-automation-provenance.mjs";
+import { keys, required } from "./npm-update-contract.mjs";
+import { sha256 } from "./github-attestation-verifier.mjs";
+
+const HEX = /^[a-f0-9]{64}$/;
+
+export const PAYLOAD_MAXIMUM = 4_194_304;
+export const TRANSPORT_MAXIMUM = 4_194_304;
+
+/** Closed public payloads contain no bearer token or executable extension field. */
+export function checkpointPayloadBytes(payload) {
+  keys(payload, ["version", "proposal", "allocation", "preview", "bundle"]);
+  required(
+    payload.version === 1 && typeof payload.bundle === "string",
+    "invalid public checkpoint payload"
+  );
+  const bytes = Buffer.from(`${canonicalJson(payload)}\n`);
+  required(bytes.length <= PAYLOAD_MAXIMUM, "checkpoint payload exceeds bound");
+  required(
+    !/\beyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\b/.test(
+      payload.bundle
+    ),
+    "bearer JWT cannot be retained"
+  );
+  return bytes;
+}
+
+/** The fixed codec changes transport only; signed subjects and canonical payloads stay intact. */
+export function encodeCheckpointBytes(bytes, version) {
+  required(
+    version === 1 || version === 2,
+    "unknown checkpoint transport version"
+  );
+  const encoded = version === 1 ? bytes : deflateSync(bytes, { level: 6 });
+  required(
+    encoded.length <= TRANSPORT_MAXIMUM,
+    "checkpoint transport exceeds bound"
+  );
+  return encoded;
+}
+
+/** An independent output ceiling and exact stream consumption refuse bombs and appended streams. */
+export function decodeCheckpointBytes(transport, version) {
+  required(
+    (version === 1 || version === 2) &&
+      transport.length > 0 &&
+      transport.length <= TRANSPORT_MAXIMUM,
+    "checkpoint transport bounds or version differ"
+  );
+  const inflated =
+    version === 2
+      ? inflateSync(transport, { info: true, maxOutputLength: PAYLOAD_MAXIMUM })
+      : undefined;
+  required(
+    !inflated || inflated.engine.bytesWritten === transport.length,
+    "checkpoint compressed stream has trailing bytes"
+  );
+  const bytes = inflated ? inflated.buffer : transport;
+  required(
+    bytes.length <= PAYLOAD_MAXIMUM,
+    "checkpoint decoded payload exceeds bound"
+  );
+  const payload = JSON.parse(
+    new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(bytes)
+  );
+  required(
+    checkpointPayloadBytes(payload).equals(bytes),
+    "checkpoint is noncanonical or duplicate-keyed"
+  );
+  return { payload, bytes };
+}
+
+/** Bind decoded bytes independently from the compressed stream and each numbered comment. */
+export function manifestFor(bytes, transport, chunks, digest, version) {
+  return {
+    version,
+    ...(version === 2
+      ? {
+          encoding: "deflate",
+          transportSha256: sha256(transport),
+          transportBytes: transport.length,
+        }
+      : {}),
+    originDescriptorSha256: digest,
+    payloadSha256: sha256(bytes),
+    bytes: bytes.length,
+    chunks: chunks.map((chunk, index) => ({ index, sha256: sha256(chunk) })),
+  };
+}
+
+/** The unique canonical completion independently declares encoded and decoded aggregate ceilings. */
+export function completionManifest(body, digest, version) {
+  const text = body.split("\n").slice(1).join("\n");
+  const manifest = JSON.parse(text);
+  keys(manifest, [
+    "version",
+    "originDescriptorSha256",
+    "payloadSha256",
+    "bytes",
+    "chunks",
+    ...(version === 2 ? ["encoding", "transportSha256", "transportBytes"] : []),
+  ]);
+  required(
+    canonicalJson(manifest) === text &&
+      manifest.version === version &&
+      manifest.originDescriptorSha256 === digest &&
+      typeof manifest.payloadSha256 === "string" &&
+      HEX.test(manifest.payloadSha256),
+    "checkpoint manifest differs"
+  );
+  required(
+    Number.isSafeInteger(manifest.bytes) &&
+      manifest.bytes > 0 &&
+      manifest.bytes <= PAYLOAD_MAXIMUM &&
+      Array.isArray(manifest.chunks) &&
+      manifest.chunks.length > 0 &&
+      manifest.chunks.length <= 256,
+    "checkpoint manifest bounds differ"
+  );
+  required(
+    version === 1 ||
+      (manifest.encoding === "deflate" &&
+        typeof manifest.transportSha256 === "string" &&
+        HEX.test(manifest.transportSha256) &&
+        Number.isSafeInteger(manifest.transportBytes) &&
+        manifest.transportBytes > 0 &&
+        manifest.transportBytes <= TRANSPORT_MAXIMUM),
+    "checkpoint encoded manifest differs"
+  );
+  return manifest;
+}

package/all/copy-overwrite/scripts/lib/npm-update-checkpoint.mjs

@@ -1,75 +1,43 @@
 // This file is managed by Lisa and IS replaced on each `lisa` run.
 // Do not edit directly — durable changes belong upstream in Lisa.
 
-/** Bounded public checkpoint storage is data only, never provenance authority. */
-import { TextDecoder } from "node:util";
+/**
+ * @file npm-update-checkpoint.mjs
+ * @description Bounded compressed public storage is data only, never provenance authority.
+ * @module npm-updater
+ */
 import { canonicalJson } from "../lisa-automation-provenance.mjs";
 import { keys, required } from "./npm-update-contract.mjs";
 import { sha256 } from "./github-attestation-verifier.mjs";
+import {
+  checkpointPayloadBytes,
+  encodeCheckpointBytes,
+  decodeCheckpointBytes,
+  manifestFor,
+  completionManifest,
+} from "./npm-update-checkpoint-codec.mjs";
 
-const MAXIMUM = 4_194_304;
 const CHUNK = 16_384;
 const PREFIX = "[lisa-npm-checkpoint]";
 const HEX = /^[a-f0-9]{64}$/;
 
-/** Closed public payloads contain no bearer token or executable extension field. */
-function payloadBytes(payload) {
-  keys(payload, ["version", "proposal", "allocation", "preview", "bundle"]);
-  required(
-    payload.version === 1 && typeof payload.bundle === "string",
-    "invalid public checkpoint payload"
-  );
-  const bytes = Buffer.from(`${canonicalJson(payload)}\n`);
-  required(bytes.length <= MAXIMUM, "checkpoint payload exceeds bound");
-  required(
-    !/\beyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\b/.test(
-      payload.bundle
-    ),
-    "bearer JWT cannot be retained"
-  );
-  return bytes;
-}
-
-/** Numbered digest-checked chunks precede one exact completion manifest. */
-export function checkpointComments(payload, originDigest) {
+/** Recognize closed wire versions, rejecting mixed or unknown formats for the same digest. */
+function relevant(comments, digest) {
   required(
-    typeof originDigest === "string" && HEX.test(originDigest),
-    "invalid checkpoint origin"
-  );
-  const bytes = payloadBytes(payload);
-  const count = Math.ceil(bytes.length / CHUNK);
-  required(count > 0 && count <= 256, "checkpoint chunk count exceeds bound");
-  const chunks = Array.from({ length: count }, (_, index) =>
-    bytes.subarray(index * CHUNK, (index + 1) * CHUNK)
+    typeof digest === "string" && HEX.test(digest),
+    "invalid checkpoint digest"
   );
-  const manifest = {
-    version: 1,
-    originDescriptorSha256: originDigest,
-    payloadSha256: sha256(bytes),
-    bytes: bytes.length,
-    chunks: chunks.map((chunk, index) => ({ index, sha256: sha256(chunk) })),
-  };
-  return [
-    ...chunks.map(
-      (chunk, index) =>
-        `${PREFIX} v1 ${originDigest} chunk ${index}/${count} ${sha256(chunk)}\n${chunk.toString("base64")}`
-    ),
-    `${PREFIX} v1 ${originDigest} complete\n${canonicalJson(manifest)}`,
-  ];
-}
-
-/** A strict marker locates data only; signatures are still required separately. */
-function relevant(comments, digest) {
   required(
     Array.isArray(comments) && comments.length <= 2000,
     "checkpoint comment inventory exceeds bound"
   );
-  return comments
-    .filter(
-      comment =>
-        typeof comment.body === "string" &&
-        comment.body.startsWith(`${PREFIX} v1 ${digest} `)
-    )
+  const bodies = comments
+    .filter(comment => {
+      const match = /^\[lisa-npm-checkpoint\] (\S+) ([a-f0-9]{64})(?: |$)/.exec(
+        comment.body ?? ""
+      );
+      return match?.[2] === digest;
+    })
     .map(comment => {
       required(
         Buffer.byteLength(comment.body) <= 24_576,
@@ -77,59 +45,62 @@ function relevant(comments, digest) {
       );
       return comment.body;
     });
+  const versions = new Set(bodies.map(body => body.split(" ")[1]));
+  required(
+    versions.size <= 1 &&
+      [...versions].every(version => version === "v1" || version === "v2"),
+    "checkpoint transport version is unknown or mixed"
+  );
+  return bodies;
 }
 
-/** The unique completion record independently bounds the declared aggregate. */
-function completionManifest(body, digest) {
-  const text = body.split("\n").slice(1).join("\n");
-  const manifest = JSON.parse(text);
-  keys(manifest, [
-    "version",
-    "originDescriptorSha256",
-    "payloadSha256",
-    "bytes",
-    "chunks",
-  ]);
+/** New writes compress; an explicitly selected legacy retry preserves its original wire bytes. */
+export function checkpointComments(payload, originDigest, version = 2) {
   required(
-    canonicalJson(manifest) === text &&
-      manifest.version === 1 &&
-      manifest.originDescriptorSha256 === digest &&
-      HEX.test(manifest.payloadSha256),
-    "checkpoint manifest differs"
+    typeof originDigest === "string" && HEX.test(originDigest),
+    "invalid checkpoint origin"
   );
-  required(
-    Number.isSafeInteger(manifest.bytes) &&
-      manifest.bytes > 0 &&
-      manifest.bytes <= MAXIMUM &&
-      Array.isArray(manifest.chunks) &&
-      manifest.chunks.length > 0 &&
-      manifest.chunks.length <= 256,
-    "checkpoint manifest bounds differ"
+  const bytes = checkpointPayloadBytes(payload);
+  const transport = encodeCheckpointBytes(bytes, version);
+  const count = Math.ceil(transport.length / CHUNK);
+  required(count > 0 && count <= 256, "checkpoint chunk count exceeds bound");
+  const chunks = Array.from({ length: count }, (_, index) =>
+    transport.subarray(index * CHUNK, (index + 1) * CHUNK)
   );
-  return manifest;
+  return [
+    ...chunks.map(
+      (chunk, index) =>
+        `${PREFIX} v${version} ${originDigest} chunk ${index}/${count} ${sha256(chunk)}\n${chunk.toString("base64")}`
+    ),
+    `${PREFIX} v${version} ${originDigest} complete\n${canonicalJson(manifestFor(bytes, transport, chunks, originDigest, version))}`,
+  ];
 }
 
-/** Each numbered chunk is canonical, bounded and byte-bound before aggregation. */
-function decodedChunks(bodies, digest, manifest) {
+/** Each chunk is canonical, bounded and byte-bound before any decompression. */
+function decodedChunks(bodies, digest, version, expectedCount) {
   const chunks = new Map();
+  let count = expectedCount;
   for (const body of bodies) {
     const match =
-      /^\[lisa-npm-checkpoint\] v1 ([a-f0-9]{64}) chunk (0|[1-9]\d*)\/([1-9]\d*) ([a-f0-9]{64})\n([A-Za-z0-9+/]+=*)$/.exec(
+      /^\[lisa-npm-checkpoint\] v([12]) ([a-f0-9]{64}) chunk (0|[1-9]\d*)\/([1-9]\d*) ([a-f0-9]{64})\n([A-Za-z0-9+/]+=*)$/.exec(
         body
       );
     required(
-      match &&
-        match[1] === digest &&
-        Number(match[3]) === manifest.chunks.length,
+      match && Number(match[1]) === version && match[2] === digest,
       "checkpoint chunk shape differs"
     );
-    const index = Number(match[2]);
-    const bytes = Buffer.from(match[5], "base64");
+    count ??= Number(match[4]);
+    const index = Number(match[3]);
+    const bytes = Buffer.from(match[6], "base64");
     required(
-      index < manifest.chunks.length &&
+      count > 0 &&
+        count <= 256 &&
+        Number(match[4]) === count &&
+        index < count &&
+        bytes.length > 0 &&
         bytes.length <= CHUNK &&
-        bytes.toString("base64") === match[5] &&
-        sha256(bytes) === match[4],
+        bytes.toString("base64") === match[6] &&
+        sha256(bytes) === match[5],
       "checkpoint chunk bytes differ"
     );
     required(
@@ -138,52 +109,108 @@ function decodedChunks(bodies, digest, manifest) {
     );
     chunks.set(index, bytes);
   }
-  return chunks;
+  required(
+    count > 0 && chunks.size === count,
+    "checkpoint missing or reordered chunk"
+  );
+  return Array.from({ length: count }, (_, index) => chunks.get(index));
 }
 
-/** Decode bounded canonical public storage; this function never authorizes recovery. */
+/** Decode bounded canonical public storage; signatures are always required separately. */
 export function decodeCheckpoint(comments, digest) {
-  required(
-    typeof digest === "string" && HEX.test(digest),
-    "invalid checkpoint digest"
-  );
   const bodies = relevant(comments, digest);
   if (!bodies.length) return undefined;
+  const version = Number(bodies[0].split(" ")[1].slice(1));
   const complete = bodies.filter(body =>
-    body.startsWith(`${PREFIX} v1 ${digest} complete\n`)
+    body.startsWith(`${PREFIX} v${version} ${digest} complete\n`)
   );
   required(complete.length === 1, "checkpoint incomplete or ambiguous");
-  const manifest = completionManifest(complete[0], digest);
+  const manifest = completionManifest(complete[0], digest, version);
   const chunks = decodedChunks(
     bodies.filter(body => body !== complete[0]),
     digest,
-    manifest
+    version,
+    manifest.chunks.length
   );
-  const ordered = manifest.chunks.map((entry, index) => {
+  manifest.chunks.forEach((entry, index) => {
     keys(entry, ["index", "sha256"]);
-    const chunk = chunks.get(index);
     required(
-      entry.index === index && chunk && sha256(chunk) === entry.sha256,
+      entry.index === index && sha256(chunks[index]) === entry.sha256,
       "checkpoint missing or reordered chunk"
     );
-    return chunk;
   });
-  const bytes = Buffer.concat(ordered);
+  const transport = Buffer.concat(chunks);
+  required(
+    version === 1 ||
+      (transport.length === manifest.transportBytes &&
+        sha256(transport) === manifest.transportSha256),
+    "checkpoint encoded aggregate differs"
+  );
+  const { payload, bytes } = decodeCheckpointBytes(transport, version);
   required(
     bytes.length === manifest.bytes && sha256(bytes) === manifest.payloadSha256,
     "checkpoint aggregate differs"
   );
-  const payload = JSON.parse(
-    new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(bytes)
+  return payload;
+}
+
+/** Complete chunk material retains its observed encoding instead of depending on recompression equality. */
+function partialCompletion(comments, digest) {
+  const bodies = relevant(comments, digest);
+  required(
+    bodies.length > 0,
+    "partial checkpoint has missing original material"
   );
+  const version = Number(bodies[0].split(" ")[1].slice(1));
+  const chunks = decodedChunks(bodies, digest, version);
+  const transport = Buffer.concat(chunks);
+  const { payload, bytes } = decodeCheckpointBytes(transport, version);
+  const completion = `${PREFIX} v${version} ${digest} complete\n${canonicalJson(manifestFor(bytes, transport, chunks, digest, version))}`;
+  return { payload, completion };
+}
+
+/** Missing completion is recoverable data, never a successful durable authorization. */
+export function recoverPartialCheckpoint(comments, digest) {
+  const recovered = partialCompletion(comments, digest);
+  return decodeCheckpoint(
+    [...comments, { body: recovered.completion }],
+    digest
+  );
+}
+
+/** Exact retries preserve observed versions; alternate valid compression is retained when all chunks exist. */
+function writeBodies(payload, digest, existing) {
+  const observed = relevant(existing, digest);
+  if (!observed.length) return checkpointComments(payload, digest);
+  const version = Number(observed[0].split(" ")[1].slice(1));
+  const complete = observed.some(body =>
+    body.startsWith(`${PREFIX} v${version} ${digest} complete\n`)
+  );
+  if (complete) {
+    required(
+      canonicalJson(decodeCheckpoint(existing, digest)) ===
+        canonicalJson(payload),
+      "checkpoint retry payload differs"
+    );
+    return [...new Set(observed)].sort((left, right) => {
+      const index = body =>
+        body.includes(" complete\n")
+          ? Infinity
+          : Number(body.split(" ")[4].split("/")[0]);
+      return index(left) - index(right);
+    });
+  }
+  const expected = checkpointComments(payload, digest, version);
+  if (observed.every(body => expected.includes(body))) return expected;
+  const recovered = partialCompletion(existing, digest);
   required(
-    payloadBytes(payload).equals(bytes),
-    "checkpoint is noncanonical or duplicate-keyed"
+    canonicalJson(recovered.payload) === canonicalJson(payload),
+    "checkpoint retry payload differs"
   );
-  return payload;
+  return [...new Set(observed), recovered.completion];
 }
 
-/** Readback before completion prevents a stored marker blessing missing bytes. */
+/** Every write still requires current authority and immediate exact provider readback. */
 export async function persistCheckpoint(
   api,
   number,
@@ -191,14 +218,34 @@ export async function persistCheckpoint(
   digest,
   authorize
 ) {
-  const bodies = checkpointComments(payload, digest);
   const endpoint = `repos/${api.policy.repository}/issues/${number}/comments`;
   const issueUrl = `https://api.github.com/repos/${api.policy.repository}/issues/${number}`;
+  await authorize();
+  let existing = await api.list(endpoint);
+  const bodies = writeBodies(payload, digest, existing);
   for (const body of bodies) {
+    const selected = relevant(existing, digest);
+    required(
+      new Set(selected).size === selected.length &&
+        selected.every(value => bodies.includes(value)),
+      "checkpoint retry transport differs"
+    );
+    let matches = existing.filter(comment => comment.body === body);
+    required(matches.length <= 1, "duplicate checkpoint write state");
+    if (matches.length) continue;
+    // Existing exact bodies require no mutation. Missing bodies always renew live authority
+    // and inventory first, including when completion is the sole remaining legacy write.
     await authorize();
-    const existing = await api.list(endpoint);
-    const matches = existing.filter(comment => comment.body === body);
-    if (body.startsWith(`${PREFIX} v1 ${digest} complete\n`)) {
+    existing = await api.list(endpoint);
+    const refreshed = relevant(existing, digest);
+    required(
+      new Set(refreshed).size === refreshed.length &&
+        refreshed.every(value => bodies.includes(value)),
+      "checkpoint retry transport differs"
+    );
+    matches = existing.filter(comment => comment.body === body);
+    required(matches.length <= 1, "duplicate checkpoint write state");
+    if (/ complete\n/.test(body)) {
       const projected = matches.length ? existing : [...existing, { body }];
       required(
         canonicalJson(decodeCheckpoint(projected, digest)) ===
@@ -206,7 +253,6 @@ export async function persistCheckpoint(
         "checkpoint chunks must read back before completion"
       );
     }
-    required(matches.length <= 1, "duplicate checkpoint write state");
     if (!matches.length) {
       const created = await api.request(endpoint, "POST", { body });
       required(

package/all/copy-overwrite/scripts/lib/npm-update-helper-inventory.mjs

@@ -46,6 +46,7 @@ const PRODUCER = [
   "cancellation",
   "cancellation-proof",
   "checkpoint",
+  "checkpoint-codec",
   "classifier-cache",
   "contract",
   "controller-broker",

package/all/copy-overwrite/scripts/lib/npm-update-recovery.mjs

@@ -23,8 +23,8 @@ import { persistCheckpoint } from "./npm-update-checkpoint.mjs";
 import { required, validateProposal } from "./npm-update-contract.mjs";
 
 import {
-  checkpointComments,
   decodeCheckpoint,
+  recoverPartialCheckpoint,
 } from "./npm-update-checkpoint.mjs";
 
 /** A new issuer binds current authority to the immutable original artifact and destination. */
@@ -66,68 +66,12 @@ export function recoveryRecord(
   };
 }
 
-/** Complete untrusted chunks can restore missing transport metadata, never authority. */
-export function recoverPartialCheckpoint(comments, digest) {
-  required(
-    Array.isArray(comments) && comments.length <= 2000,
-    "partial checkpoint inventory exceeds bound"
-  );
-  const bodies = comments.filter(comment =>
-    comment.body?.startsWith(`[lisa-npm-checkpoint] v1 ${digest} `)
-  );
-  const chunks = new Map();
-  let count;
-  for (const { body } of bodies) {
-    const match =
-      /^\[lisa-npm-checkpoint\] v1 ([a-f0-9]{64}) chunk (0|[1-9]\d*)\/([1-9]\d*) ([a-f0-9]{64})\n([A-Za-z0-9+/]+=*)$/.exec(
-        body
-      );
-    required(
-      match && Buffer.byteLength(body) <= 24_576 && match[1] === digest,
-      "partial checkpoint chunk differs"
-    );
-    count ??= Number(match[3]);
-    const index = Number(match[2]);
-    const bytes = Buffer.from(match[5], "base64");
-    required(
-      count <= 256 &&
-        Number(match[3]) === count &&
-        index < count &&
-        bytes.length <= 16_384 &&
-        bytes.toString("base64") === match[5] &&
-        sha256(bytes) === match[4],
-      "partial checkpoint bounds or digest differ"
-    );
-    required(
-      !chunks.has(index) || chunks.get(index).equals(bytes),
-      "partial checkpoint has differing duplicate chunk"
-    );
-    chunks.set(index, bytes);
-  }
-  required(
-    count > 0 && chunks.size === count,
-    "partial checkpoint has missing original material"
-  );
-  const bytes = Buffer.concat(
-    Array.from({ length: count }, (_, index) => chunks.get(index))
-  );
-  required(
-    bytes.length <= 4_194_304,
-    "partial checkpoint exceeds aggregate bound"
-  );
-  const payload = JSON.parse(
-    new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(bytes)
-  );
-  const complete = checkpointComments(payload, digest).at(-1);
-  return decodeCheckpoint([...comments, { body: complete }], digest);
-}
-
 /** Unsigned draft bytes aid retry; only the separately verified origin can authorize gates. */
 export function locateCheckpoint(comments, proposal, policy) {
   const digests = new Set(
     comments.flatMap(comment => {
       const match =
-        /^\[lisa-npm-checkpoint\] v1 ([a-f0-9]{64}) (?:chunk|complete)\b/.exec(
+        /^\[lisa-npm-checkpoint\] \S+ ([a-f0-9]{64}) (?:chunk|complete)\b/.exec(
           comment.body ?? ""
         );
       return match && match[1] !== proposal.key ? [match[1]] : [];
@@ -136,10 +80,14 @@ export function locateCheckpoint(comments, proposal, policy) {
   required(digests.size <= 1, "multiple origin checkpoints are preserved");
   const digest = [...digests][0] ?? proposal.key;
   const present = comments.filter(comment =>
-    comment.body?.startsWith(`[lisa-npm-checkpoint] v1 ${digest} `)
+    new RegExp(`^\\[lisa-npm-checkpoint\\] \\S+ ${digest} `).test(
+      comment.body ?? ""
+    )
   );
   const complete = present.some(comment =>
-    comment.body.startsWith(`[lisa-npm-checkpoint] v1 ${digest} complete\n`)
+    new RegExp(`^\\[lisa-npm-checkpoint\\] \\S+ ${digest} complete\\n`).test(
+      comment.body
+    )
   );
   const payload = complete
     ? decodeCheckpoint(comments, digest)
@@ -167,6 +115,7 @@ export {
   checkpointComments,
   decodeCheckpoint,
   persistCheckpoint,
+  recoverPartialCheckpoint,
 } from "./npm-update-checkpoint.mjs";
 
 /** Renewal verifies fresh authority against every immutable original identity field. */