@codyswann/lisa 4.72.6 → 4.73.0

package/all/copy-overwrite/scripts/lib/automation-provenance-contract.mjs

@@ -36,6 +36,25 @@ export function optionalLockFields(value) {
   return ["bunLockSha256"];
 }
 
+/** Optional runtime authority is a digest, never an unsigned executable profile. */
+export function optionalRuntimeFields(value) {
+  if (!Object.hasOwn(value, "runtimeSha256")) return [];
+  requireProof(
+    typeof value.runtimeSha256 === "string" && HEX.test(value.runtimeSha256),
+    "invalid original Rails runtime digest"
+  );
+  return ["runtimeSha256"];
+}
+
+/** One exact optional projection preserves historical keys at producer and verifier boundaries. */
+export function signedProposalFields(value) {
+  return Object.fromEntries(
+    [...optionalLockFields(value), ...optionalRuntimeFields(value)].map(
+      name => [name, value[name]]
+    )
+  );
+}
+
 /** Signed original presence selects one closed two- or three-file cohort. */
 export function proposalFileNames(value) {
   const files = optionalLockFields(value).length

package/all/copy-overwrite/scripts/lib/automation-provenance-local.mjs

@@ -14,11 +14,12 @@ import {
   canonicalJson,
   exactKeys,
   proposalFileNames,
-  optionalLockFields,
+  signedProposalFields,
   DESCRIPTOR_KEYS,
   HEX,
   OBJECT_ID,
 } from "./automation-provenance-contract.mjs";
+import { assertCommittedRuntime } from "./npm-update-rails-runtime-contract.mjs";
 
 /** Git reads always use the actual checkout and bounded shared runner. */
 export function git(args) {
@@ -98,7 +99,7 @@ export function localDescriptor(descriptor, messageBytes, reference, policy) {
   }).decode(messageBytes);
   exactKeys(
     descriptor,
-    [...DESCRIPTOR_KEYS, ...optionalLockFields(descriptor)],
+    [...DESCRIPTOR_KEYS, ...Object.keys(signedProposalFields(descriptor))],
     "descriptor"
   );
   requireProof(
@@ -142,6 +143,7 @@ export function localDescriptor(descriptor, messageBytes, reference, policy) {
     descriptor.parent === git(["rev-parse", "HEAD"]),
     "proposal parent differs"
   );
+  assertCommittedRuntime(descriptor, git);
   requireProof(
     OBJECT_ID.test(descriptor.tree) && descriptor.tree === git(["write-tree"]),
     "final staged tree differs"

package/all/copy-overwrite/scripts/lib/history-secret-evidence-shape.mjs

@@ -1,6 +1,9 @@
 // This file is managed by Lisa and IS replaced on each `lisa` run.
 // Do not edit directly — durable changes belong upstream in Lisa.
 /** Bounded lossless evidence syntax; no digest is authenticated by syntax alone. */
+const SOURCE_MAP_FORMAT = "json-source-map";
+const PROOF_MAP_FORMAT = "json-proof-map";
+const TAXONOMY = "Disk/missing/corrupt";
 const credentialField =
   /^(?:api[_-]?key|access[_-]?token|password|passwd|secret)$/iu;
 const credentialToken =
@@ -34,15 +37,18 @@ const isHash = value =>
 
 /** Native validation and duplicate-aware lexical spans share the exact same text. */
 const lexical = text => {
+  const tokens = [];
+  for (const token of text.matchAll(
+    /"(?:\\[\s\S]|[^"\\])*"|[{}[\],:]|[^{}[\],:\s]+/gu
+  )) {
+    if (tokens.length >= 8192) throw new Error("Bounded JSON tokens");
+    tokens.push(token);
+  }
   const value = JSON.parse(text);
-  const tokens = [
-    ...text.matchAll(/"(?:\\[\s\S]|[^"\\])*"|[{}[\],:]|[^{}[\],:\s]+/gu),
-  ];
-  if (tokens.length > 8192) throw new Error("Bounded JSON tokens");
   const state = { cursor: 0, spans: [] };
   visit(tokens, state, [], 0, text);
   if (state.cursor !== tokens.length) throw new Error("Trailing JSON tokens");
-  return { value, spans: state.spans };
+  return { value, spans: state.spans, tokens };
 };
 
 /** Duplicate decoded keys and escaped attribution spellings always fail closed. */
@@ -161,6 +167,392 @@ export const evidenceMaps = bytes => {
   return result;
 };
 
+const coordinateFormats = new Map([
+  [
+    SOURCE_MAP_FORMAT,
+    new Set([
+      "/selected_artifact_hashes",
+      "/source_hashes",
+      "/source_hashes_after",
+    ]),
+  ],
+  ["json-root-map", new Set([""])],
+  ["markdown-json-files", new Set(["/files"])],
+  [PROOF_MAP_FORMAT, new Set(["/proof_sha256"])],
+]);
+const record = value =>
+  value !== null && typeof value === "object" && !Array.isArray(value);
+const fieldsExactly = (value, fields) =>
+  record(value) &&
+  Object.keys(value).length === fields.length &&
+  fields.every(field => Object.hasOwn(value, field));
+const objectId = (value, width) =>
+  typeof value === "string" &&
+  [40, 64].includes(width) &&
+  new RegExp(`^[a-f0-9]{${width}}$`, "u").test(value);
+const documentText = bytes => {
+  if (bytes.length > 1024 * 1024) return null;
+  const text = bytes.toString("utf8");
+  return Buffer.from(text).equals(bytes) ? text : null;
+};
+const coordinateOrigin = (origin, width) =>
+  fieldsExactly(origin, [
+    "commit",
+    "blob",
+    "path",
+    "format",
+    "map_pointer",
+    "value_span",
+  ]) &&
+  objectId(origin.commit, width) &&
+  objectId(origin.blob, width) &&
+  safeSourcePath(origin.path) &&
+  coordinateFormats.get(origin.format)?.has(origin.map_pointer) === true &&
+  Array.isArray(origin.value_span) &&
+  origin.value_span.length === 2 &&
+  origin.value_span.every(
+    value => Number.isSafeInteger(value) && value >= 0 && value <= 1024 * 1024
+  ) &&
+  origin.value_span[1] - origin.value_span[0] === 64;
+const coordinatePreimage = (preimage, width) => {
+  if (preimage?.kind === "source")
+    return Object.hasOwn(preimage, "commit")
+      ? fieldsExactly(preimage, ["kind", "commit"]) &&
+          objectId(preimage.commit, width)
+      : fieldsExactly(preimage, ["kind"]);
+  return (
+    fieldsExactly(preimage, ["kind", "commit", "path"]) &&
+    preimage.kind === "archive" &&
+    objectId(preimage.commit, width) &&
+    preimage.path === "evidence/archive/neutral-artifact.json"
+  );
+};
+
+/** Closed version1 coordinates carry no digest, opaque original key or caller role. */
+export const coordinateManifest = (bytes, width) => {
+  const text = documentText(bytes);
+  if (text === null) return null;
+  try {
+    const parsed = lexical(text);
+    if (
+      parsed.tokens.some(
+        token =>
+          token[0].startsWith('"') &&
+          token[0] !== JSON.stringify(JSON.parse(token[0]))
+      )
+    )
+      return null;
+    const value = parsed.value;
+    if (
+      !fieldsExactly(value, ["version", "entries"]) ||
+      value.version !== 1 ||
+      !Array.isArray(value.entries) ||
+      value.entries.length > 256
+    )
+      return null;
+    if (
+      value.entries.some(
+        entry =>
+          !fieldsExactly(entry, ["origin", "preimage"]) ||
+          !coordinateOrigin(entry.origin, width) ||
+          !coordinatePreimage(entry.preimage, width)
+      )
+    )
+      return null;
+    return value.entries;
+  } catch {
+    return null;
+  }
+};
+
+/** Scan maximal opening markers without backtracking across a long fence line. */
+const openingFence = line => {
+  const state = { start: 0, end: 0 };
+  while (state.start < 3 && line[state.start] === " ") state.start++;
+  state.end = state.start;
+  const marker = line[state.start];
+  if (marker !== "`" && marker !== "~") return null;
+  while (line[state.end] === marker) state.end++;
+  const info = line.slice(state.end);
+  return state.end - state.start >= 3 && !/[\r\n]/u.test(info)
+    ? [line.slice(state.start, state.end), info]
+    : null;
+};
+
+/** Strip only trailing CR/LF bytes, with a single bounded backwards pass. */
+const withoutLineEnding = line => {
+  const state = { end: line.length };
+  while (state.end > 0 && /[\r\n]/u.test(line[state.end - 1])) state.end--;
+  return line.slice(0, state.end);
+};
+
+/** Track actual Markdown fences, including nested-looking text inside another fence. */
+const markdownFences = text => {
+  const result = [];
+  let active = null;
+  let offset = 0;
+  for (const line of text.split(/(?<=\n)/u)) {
+    const clean = withoutLineEnding(line);
+    if (active) {
+      const close = clean.match(/^ {0,3}(`{3,}|~{3,})[ \t]*$/u);
+      if (
+        close &&
+        close[1][0] === active.marker[0] &&
+        close[1].length >= active.marker.length
+      ) {
+        result.push({
+          ...active,
+          bodyEnd: offset,
+          end: offset + line.length,
+          closed: true,
+        });
+        active = null;
+      }
+    } else {
+      const open = openingFence(clean);
+      if (open && !(open[0][0] === "`" && open[1].includes("`")))
+        active = {
+          start: offset,
+          marker: open[0],
+          info: open[1].trim(),
+          bodyStart: offset + line.length,
+        };
+    }
+    offset += line.length;
+  }
+  if (active)
+    result.push({
+      ...active,
+      bodyEnd: text.length,
+      end: text.length,
+      closed: false,
+    });
+  return result;
+};
+const markdownTokensWithinBudget = text => {
+  let count = 0;
+  for (const _token of text.matchAll(
+    /"(?:\\[\s\S]|[^"\\])*"|[`~]+|[\p{L}\p{N}]+|[^\s\p{L}\p{N}]/gu
+  ))
+    if (++count > 8192) return false;
+  return true;
+};
+const completeMap = (value, isPath) =>
+  record(value) &&
+  Object.keys(value).length > 0 &&
+  Object.keys(value).length <= 256 &&
+  Object.entries(value).every(
+    ([key, literal]) => isPath(key) && isHash(literal)
+  );
+const opaqueKey = key => typeof key === "string" && key.length > 0;
+const coordinateMap = (parsed, role, format, offset = 0) => {
+  const value = role === null ? parsed.value : parsed.value[role];
+  if (
+    !completeMap(
+      value,
+      format === PROOF_MAP_FORMAT ? opaqueKey : safeSourcePath
+    )
+  )
+    return null;
+  const spans = parsed.spans
+    .filter(span =>
+      role === null
+        ? span.path.length === 1
+        : span.path.length === 2 && span.path[0] === role
+    )
+    .map(span => ({
+      file: span.path.at(-1),
+      hash: span.hash,
+      start: span.start + offset,
+      end: span.end + offset,
+    }));
+  if (spans.length !== Object.keys(value).length) return null;
+  return {
+    kind: format === PROOF_MAP_FORMAT ? "proof" : "source",
+    format,
+    pointer: role === null ? "" : `/${role}`,
+    value: parsed.value,
+    spans,
+  };
+};
+const coordinateJsonMaps = parsed => {
+  if (!record(parsed.value)) return [];
+  if (completeMap(parsed.value, safeSourcePath))
+    return [coordinateMap(parsed, null, "json-root-map")];
+  const roles = [
+    "selected_artifact_hashes",
+    "source_hashes",
+    "source_hashes_after",
+    "proof_sha256",
+  ].filter(role => Object.hasOwn(parsed.value, role));
+  const result = roles.map(role =>
+    coordinateMap(
+      parsed,
+      role,
+      role === "proof_sha256" ? PROOF_MAP_FORMAT : SOURCE_MAP_FORMAT
+    )
+  );
+  return result.some(map => map === null) ? [] : result;
+};
+
+/** Complete documents derive exact fixed map roles independently of manifest assertions. */
+export const coordinateMaps = bytes => {
+  const text = documentText(bytes);
+  if (text === null) return [];
+  try {
+    return coordinateJsonMaps(lexical(text));
+  } catch {
+    /* A complete Markdown document may supply one independently parsed JSON fence. */
+  }
+  if (!markdownTokensWithinBudget(text)) return [];
+  const blocks = markdownFences(text).filter(block => block.info === "json");
+  if (blocks.length !== 1 || !blocks[0].closed) return [];
+  try {
+    const block = blocks[0];
+    const parsed = lexical(text.slice(block.bodyStart, block.bodyEnd));
+    if (
+      !record(parsed.value) ||
+      !completeMap(parsed.value.files, safeSourcePath) ||
+      !completeMap(parsed.value.logs, opaqueKey)
+    )
+      return [];
+    const map = coordinateMap(
+      parsed,
+      "files",
+      "markdown-json-files",
+      Buffer.byteLength(text.slice(0, block.bodyStart))
+    );
+    return map ? [map] : [];
+  } catch {
+    return [];
+  }
+};
+
+const paragraphBreak = line =>
+  /^\s*$/u.test(line) ||
+  /^ {0,3}(?:>|#{1,6}[ \t]|`{3,}|~{3,}|(?:[-*+] |\d+[.)] ))/u.test(line) ||
+  /^(?: {4}|\t)/u.test(line);
+const paragraphAt = (text, position) => {
+  const lines = [];
+  let start = 0;
+  for (const textLine of text.split(/(?<=\n)/u)) {
+    lines.push({ text: textLine, start, end: start + textLine.length });
+    start += textLine.length;
+  }
+  const index = lines.findIndex(
+    line => position >= line.start && position < line.end
+  );
+  if (index < 0) return null;
+  let first = index;
+  let last = index;
+  while (first > 0 && !paragraphBreak(lines[first].text)) {
+    if (/^\s*$/u.test(lines[first - 1].text)) break;
+    if (paragraphBreak(lines[first - 1].text)) {
+      if (/^ {0,3}>/u.test(lines[first - 1].text)) return null;
+      if (/^ {0,3}[-*+] /u.test(lines[first - 1].text)) first--;
+      break;
+    }
+    first--;
+  }
+  while (last + 1 < lines.length && !paragraphBreak(lines[last + 1].text))
+    last++;
+  return {
+    start: lines[first].start,
+    text: text.slice(lines[first].start, lines[last].end),
+  };
+};
+const inlineCode = text => {
+  const ranges = [];
+  const runs = [...text.matchAll(/`+/gu)];
+  let index = 0;
+  while (index < runs.length) {
+    const close = runs.findIndex(
+      (run, candidate) =>
+        candidate > index && run[0].length === runs[index][0].length
+    );
+    if (close < 0) return null;
+    ranges.push([runs[index].index, runs[close].index + runs[close][0].length]);
+    index = close + 1;
+  }
+  return ranges;
+};
+const quotedRanges = text => {
+  const ranges = [];
+  let quote = null;
+  let start = 0;
+  for (let index = 0; index < text.length; index++) {
+    const char = text[index];
+    if (char !== "'" && char !== '"') continue;
+    if (quote === char) {
+      ranges.push([start, index + 1]);
+      quote = null;
+    } else if (quote === null) {
+      if (char === "'" && /[\p{L}\p{N}]/u.test(text[index - 1] ?? "")) continue;
+      quote = char;
+      start = index;
+    }
+  }
+  return quote === null ? ranges : null;
+};
+
+/** One exact taxonomy occurrence may live inside a complete larger Markdown paragraph. */
+export const paragraphNarrativeSpan = (bytes, lineStart, lineEnd) => {
+  const text = documentText(bytes);
+  if (text === null || !markdownTokensWithinBudget(text)) return null;
+  const position = bytes.subarray(0, lineStart).toString("utf8").length;
+  if (
+    markdownFences(text).some(
+      block => position >= block.start && position < block.end
+    )
+  )
+    return null;
+  const paragraph = paragraphAt(text, position);
+  if (!paragraph) return null;
+  const phrase = `AccessDenied boundaries, ${TAXONOMY} falsifications`;
+  const index = paragraph.text.indexOf(phrase);
+  if (
+    index < 0 ||
+    paragraph.text.indexOf(phrase, index + 1) >= 0 ||
+    !/[,.]/u.test(paragraph.text[index + phrase.length] ?? "")
+  )
+    return null;
+  const ranges = inlineCode(paragraph.text);
+  if (
+    ranges === null ||
+    ranges.some(([start, end]) => index < end && index + phrase.length > start)
+  )
+    return null;
+  let prose = paragraph.text;
+  for (const [start, end] of [...ranges].reverse())
+    prose = `${prose.slice(0, start)}identifier${prose.slice(end)}`;
+  const quotes = quotedRanges(prose);
+  const proseIndex = prose.indexOf(phrase);
+  if (
+    quotes === null ||
+    quotes.some(
+      ([start, end]) => proseIndex < end && proseIndex + phrase.length > start
+    )
+  )
+    return null;
+  if (
+    !/^(?: {0,3}[-*+] )?\p{L}[\p{L}\p{N}\s,./():;!?"'-]*[.!?]\s*$/u.test(prose)
+  )
+    return null;
+  if (
+    [...prose.matchAll(/(?:^|\s)([a-z_-]+)\s*:/giu)].some(
+      match => credentialField.test(match[1]) || credentialToken.test(match[1])
+    )
+  )
+    return null;
+  const start = Buffer.byteLength(
+    text.slice(0, paragraph.start + index + phrase.indexOf(TAXONOMY))
+  );
+  const end = start + TAXONOMY.length;
+  return start >= lineStart && end <= lineEnd
+    ? { hash: TAXONOMY, start, end }
+    : null;
+};
+
 /** Only the fixed taxonomy in ordinary prose, outside Markdown code, is a candidate. */
 export const narrativeSpan = (bytes, lineStart, lineEnd) => {
   const prior = bytes.subarray(0, lineStart).toString("utf8");
@@ -172,7 +564,7 @@ export const narrativeSpan = (bytes, lineStart, lineEnd) => {
   const line = bytes.subarray(lineStart, lineEnd).toString("utf8");
   const prose = line.replace(/`[^`\r\n]{1,256}`/gu, "identifier");
   if (!/^(?:[-*] )?[A-Za-z][A-Za-z0-9 ,./():-]*\.$/u.test(prose)) return null;
-  const taxonomy = "Disk/missing/corrupt";
+  const taxonomy = TAXONOMY;
   const phrase = `AccessDenied boundaries, ${taxonomy} falsifications`;
   const index = line.indexOf(phrase);
   if (index < 0 || line.indexOf(phrase, index + 1) >= 0) return null;