@codyswann/lisa 4.73.7 → 4.73.9

package/all/copy-overwrite/scripts/lib/github-attestation-recovery.mjs

@@ -8,6 +8,7 @@ import {
   verifyAssignable,
 } from "./github-attestation-provider.mjs";
 import { boundedSpawnSync } from "./bounded-spawn.mjs";
+import { withProvenancePhase } from "./npm-update-invariants.mjs";
 import {
   requireProof,
   verifiedRole,
@@ -251,45 +252,57 @@ export function verifyRecoveryOrigin(
   scope,
   execute = boundedSpawnSync
 ) {
-  validateRecovery(recovery, descriptor, digest, policy);
-  for (const key of [
-    "npmPolicySha256",
-    "proposalKey",
-    "leafBodySha256",
-    "commit",
-  ])
+  withProvenancePhase("recovery-local", () => {
+    validateRecovery(recovery, descriptor, digest, policy);
+    for (const key of [
+      "npmPolicySha256",
+      "proposalKey",
+      "leafBodySha256",
+      "commit",
+    ])
+      requireProof(
+        recovery[key] === scope[key],
+        `current recovery ${key} differs`
+      );
     requireProof(
-      recovery[key] === scope[key],
-      `current recovery ${key} differs`
+      process.env.GITHUB_RUN_ID === recovery.runId &&
+        process.env.GITHUB_RUN_ATTEMPT === recovery.runAttempt,
+      "recovery replayed into different current invocation"
     );
-  requireProof(
-    process.env.GITHUB_RUN_ID === recovery.runId &&
-      process.env.GITHUB_RUN_ATTEMPT === recovery.runAttempt,
-    "recovery replayed into different current invocation"
+  });
+  const origin = withProvenancePhase("historical-provider", () =>
+    verifyHistoricalProvider(policy, descriptor, execute)
   );
-  const origin = verifyHistoricalProvider(policy, descriptor, execute);
-  verifyHistoricalDescriptor(
-    policy,
-    descriptor,
-    paths,
-    digest,
-    origin.run,
-    origin.claim,
-    execute
+  withProvenancePhase("historical-signature", () =>
+    verifyHistoricalDescriptor(
+      policy,
+      descriptor,
+      paths,
+      digest,
+      origin.run,
+      origin.claim,
+      execute
+    )
   );
-  verifyRecoveryAttestation(
-    policy,
-    recovery,
-    paths,
-    scope.recoverySha256,
-    execute
+  withProvenancePhase("recovery-signature", () =>
+    verifyRecoveryAttestation(
+      policy,
+      recovery,
+      paths,
+      scope.recoverySha256,
+      execute
+    )
   );
-  verifyRecoveryProvider(
-    policy,
-    descriptor,
-    recovery,
-    scope.maintainer,
-    execute
+  withProvenancePhase("recovery-provider", () =>
+    verifyRecoveryProvider(
+      policy,
+      descriptor,
+      recovery,
+      scope.maintainer,
+      execute
+    )
+  );
+  withProvenancePhase("assignable", () =>
+    verifyAssignable(policy, scope.maintainer, execute)
   );
-  verifyAssignable(policy, scope.maintainer, execute);
 }

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

@@ -17,7 +17,10 @@ import { affirmRuntimeProfile } from "./npm-update-rails-runtime-contract.mjs";
 import { prepareRailsTools } from "./npm-update-rails-tools.mjs";
 import { openRailsMysqlRuntime } from "./npm-update-rails-mysql.mjs";
 import { installOriginalManager } from "./npm-update-hook-installation.mjs";
-import { withStage } from "./npm-update-invariants.mjs";
+import {
+  withStage,
+  inheritProvenanceFailure,
+} from "./npm-update-invariants.mjs";
 
 const INSTALL_STAGE = "gate-install";
 const VALIDATE_STAGE = "gate-validate";
@@ -66,6 +69,17 @@ function nativeStep(context, env, command, args, maximum = 3_145_728) {
     env,
     timeout: remainingGateTime(context.deadline),
     maximum,
+  }).catch(error => {
+    if (
+      command === "node" &&
+      env.LISA_NPM_HOOK_ROLE === "commit" &&
+      typeof env.HOME === "string" &&
+      args.length === 2 &&
+      args[0] === "scripts/lisa-automation-provenance.mjs" &&
+      args[1] === join(env.HOME, "message")
+    )
+      inheritProvenanceFailure(error);
+    throw error;
   });
 }
 

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

@@ -9,6 +9,11 @@ import { realpathSync, lstatSync } from "node:fs";
 import { resolve, join, basename } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { binaryDigest } from "./npm-update-isolation.mjs";
+import {
+  withProvenancePhase,
+  recordProvenancePhase,
+  provenanceFailure,
+} from "./npm-update-invariants.mjs";
 
 const ENTRY = fileURLToPath(import.meta.url);
 const PRELOAD = fileURLToPath(
@@ -111,55 +116,79 @@ export function tokenFreeHookEnvironment(source) {
   return env;
 }
 
+/** Input consumes the same fixed bound and one original deadline observation before native execution. */
+async function originalHookInput(context) {
+  const chunks = [];
+  let size = 0;
+  try {
+    for await (const chunk of process.stdin) {
+      size += chunk.length;
+      required(size <= 4_194_304, "original hook stdin exceeded");
+      chunks.push(chunk);
+    }
+    const timeout = Math.min(1_800_000, context.deadline - Date.now());
+    required(timeout > 0, "original hook phase expired");
+    return { input: Buffer.concat(chunks), timeout };
+  } catch (error) {
+    recordProvenancePhase(error, "gateway-input");
+    throw error;
+  }
+}
+
 async function main() {
   const args = process.argv.slice(2);
-  required(
-    args.length >= 3 && args[0] === "--context" && args[2] === "--",
-    "invalid hosted Node gateway"
+  withProvenancePhase("gateway-context", () =>
+    required(
+      args.length >= 3 && args[0] === "--context" && args[2] === "--",
+      "invalid hosted Node gateway"
+    )
+  );
+  const context = withProvenancePhase("gateway-context", () =>
+    hostedHookContext(args[1])
   );
-  const context = hostedHookContext(args[1]);
   const original = args.slice(3);
-  const entry = hookEntry(context, original, realpathSync(process.cwd()));
-  if (entry)
-    required(
-      !original.some(arg =>
-        /^(?:-r|--require|--import|--(?:experimental-)?loader)(?:=|$)/.test(arg)
-      ) &&
-        !process.env.NODE_OPTIONS &&
-        !process.env.NODE_PATH,
-      "unqualified original canonical hook loader"
-    );
+  const entry = withProvenancePhase("gateway-entry", () =>
+    hookEntry(context, original, realpathSync(process.cwd()))
+  );
+  withProvenancePhase("gateway-entry", () => {
+    if (entry)
+      required(
+        !original.some(arg =>
+          /^(?:-r|--require|--import|--(?:experimental-)?loader)(?:=|$)/.test(
+            arg
+          )
+        ) &&
+          !process.env.NODE_OPTIONS &&
+          !process.env.NODE_PATH,
+        "unqualified original canonical hook loader"
+      );
+  });
   const env = tokenFreeHookEnvironment(process.env);
   if (entry) env.LISA_NPM_HOSTED_HOOK_CONTEXT = context.file;
   else delete env.LISA_NPM_HOSTED_HOOK_CONTEXT;
-  const chunks = [];
-  let size = 0;
-  for await (const chunk of process.stdin) {
-    size += chunk.length;
-    required(size <= 4_194_304, "original hook stdin exceeded");
-    chunks.push(chunk);
-  }
-  const timeout = Math.min(1_800_000, context.deadline - Date.now());
-  required(timeout > 0, "original hook phase expired");
+  const { input, timeout } = await originalHookInput(context);
   const result = await runProcess(
     context.native.node.path,
     entry ? ["--import", pathToFileURL(PRELOAD).href, ...original] : original,
     {
       cwd: process.cwd(),
       env,
-      input: Buffer.concat(chunks),
+      input,
       timeout,
       maximum: 8_388_608,
       allowed: Array.from({ length: 256 }, (_, code) => code),
     }
-  );
+  ).catch(error => {
+    recordProvenancePhase(error, "gateway-child");
+    throw error;
+  });
   process.stdout.write(result.stdout);
   process.stderr.write(result.stderr);
   process.exitCode = result.code;
 }
 
 if (process.argv[1] && resolve(process.argv[1]) === ENTRY)
-  main().catch(() => {
-    process.stderr.write("original hosted hook command failed\n");
+  main().catch(error => {
+    process.stderr.write(`${provenanceFailure(error)}\n`);
     process.exitCode = 1;
   });

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

@@ -29,6 +29,73 @@ const stages = new Set([
   "gate-output",
 ]);
 const diagnostics = new WeakMap();
+const capturedErrors = new WeakMap();
+const provenancePhases = new Set([
+  "local-proof",
+  "configuration",
+  "verifier",
+  "canonical-context",
+  "recovery-local",
+  "historical-provider",
+  "historical-signature",
+  "recovery-signature",
+  "recovery-provider",
+  "assignable",
+  "ordinary-signature",
+  "ordinary-provider",
+  "final-proof",
+  "gateway-context",
+  "gateway-entry",
+  "gateway-input",
+  "gateway-child",
+]);
+const provenancePrefix =
+  "Invalid automation provenance: required proof, policy or provider evidence failed";
+
+/** A synchronous verifier keeps its original exception and innermost source-selected phase. */
+export function withProvenancePhase(phase, operation) {
+  required(provenancePhases.has(phase), "invalid provenance diagnostic phase");
+  try {
+    return operation();
+  } catch (error) {
+    recordProvenancePhase(error, phase);
+    throw error;
+  }
+}
+
+/** Shared sync/async catches never inspect exception properties, including hostile getters. */
+export function recordProvenancePhase(error, phase) {
+  required(provenancePhases.has(phase), "invalid provenance diagnostic phase");
+  if (
+    error !== null &&
+    (typeof error === "object" || typeof error === "function")
+  ) {
+    const prior = diagnostics.get(error) ?? {};
+    diagnostics.set(error, { ...prior, provenance: prior.provenance ?? phase });
+  }
+}
+
+/** Canonical CLI and gateway failures expose one closed label, never provider or exception text. */
+export function provenanceFailure(error) {
+  return `${provenancePrefix} (phase=${diagnostics.get(error)?.provenance ?? "unknown"})`;
+}
+
+/** Only a complete fixed diagnostic from an observed native exit-one can add a phase, never authority. */
+export function inheritProvenanceFailure(error) {
+  const facts = diagnostics.get(error);
+  const bytes = capturedErrors.get(error);
+  if (
+    facts?.native !== "exit" ||
+    facts.status !== 1 ||
+    !bytes ||
+    bytes.length > 256
+  )
+    return;
+  const text = bytes.toString("utf8");
+  for (const phase of provenancePhases)
+    if (text === `${provenancePrefix} (phase=${phase})\n`)
+      recordProvenancePhase(error, phase);
+}
 const signals = new Set([
   "SIGTERM",
   "SIGINT",
@@ -81,7 +148,16 @@ export async function withStage(stage, operation) {
 }
 
 /** Only native capture registers observed close facts; exception properties never establish provenance. */
-export function recordNativeFailure(error, category, status, signal, errno) {
+export function recordNativeFailure(
+  error,
+  category,
+  status,
+  signal,
+  errno,
+  stderr
+) {
+  if (Buffer.isBuffer(stderr) && stderr.length <= 256)
+    capturedErrors.set(error, Buffer.from(stderr));
   diagnostics.set(error, {
     ...diagnostics.get(error),
     native: categories.has(category) ? category : "unknown",
@@ -101,6 +177,7 @@ export function publicFailure(error) {
     if (facts.signal) parts.push(`signal=${facts.signal}`);
     if (facts.errno) parts.push(`errno=${facts.errno}`);
   }
+  if (facts?.provenance) parts.push(`provenance=${facts.provenance}`);
   return `npm updater failed: required policy, authorization, installation, gate or exact publication evidence was unavailable (${parts.join(" ")})`;
 }
 

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

@@ -95,6 +95,29 @@ export function runProcess(
   });
 }
 
+/** Retain the original native error and captured bytes while registering only observed close facts. */
+function observedFailure(error, observation) {
+  const {
+    chunks,
+    errors,
+    command,
+    code,
+    nativeCompleted,
+    category,
+    signal,
+    errno,
+  } = observation;
+  const stderr = Buffer.concat(errors);
+  recordNativeFailure(error, category, code, signal, errno, stderr);
+  return Object.assign(error, {
+    stdout: Buffer.concat(chunks),
+    stderr,
+    command,
+    code,
+    nativeCompleted,
+  });
+}
+
 /** Native close, not cancellation delivery, completes an owned child. */
 function captureProcess(
   child,
@@ -145,20 +168,16 @@ function captureProcess(
       if (failure || signal || !allowed.includes(code)) {
         const error =
           failure ?? new Error(`npm updater: child failed (${code ?? signal})`);
-        recordNativeFailure(
-          error,
-          category ?? (signal ? "signal" : "exit"),
-          code,
-          signal,
-          errno
-        );
         reject(
-          Object.assign(error, {
-            stdout: Buffer.concat(chunks),
-            stderr: Buffer.concat(errors),
+          observedFailure(error, {
+            chunks,
+            errors,
             command,
             code,
             nativeCompleted: !failure && !signal,
+            category: category ?? (signal ? "signal" : "exit"),
+            signal,
+            errno,
           })
         );
         return;

package/all/copy-overwrite/scripts/lisa-automation-provenance.mjs

@@ -7,6 +7,10 @@ import {
   verifyRecoveryOrigin,
 } from "./lib/github-attestation-recovery.mjs";
 import { invokedAsScript } from "./lib/invoked-as-script.mjs";
+import {
+  withProvenancePhase,
+  provenanceFailure,
+} from "./lib/npm-update-invariants.mjs";
 import {
   assertPinnedVerifier,
   requireProof,
@@ -29,6 +33,8 @@ import {
 } from "./lib/automation-provenance-local.mjs";
 export { canonicalJson } from "./lib/automation-provenance-contract.mjs";
 
+const LOCAL_PROOF = "local-proof";
+
 /** A present but malformed reference is a failure, even with ordinary AI trailers. */
 export function automationReference(message) {
   const lines = message
@@ -88,14 +94,8 @@ function recoveryPermission(
   );
 }
 
-/** Verify fixed private proof against the final message, tree, binding and provider. */
-export function verifyAutomationProvenance(messageFile) {
-  const messageBytes = privateBytes(messageFile, 65_536, false);
-  const message = messageBytes.toString("utf8");
-  const reference = automationReference(message);
-  if (!reference) return false;
-  const { config, policy } = trustedConfiguration(git);
-  const { paths, optional, bytes, bundleBytes, descriptor } = proofSnapshot();
+/** Keep unchanged local authorization together without obscuring the canonical phase. */
+function verifyLocalProposal(descriptor, messageBytes, reference, policy) {
   localDescriptor(descriptor, messageBytes, reference, policy);
   npmProposal(descriptor, git);
   requireProof(
@@ -110,30 +110,18 @@ export function verifyAutomationProvenance(messageFile) {
       ),
     "deterministic proposal key differs"
   );
-  assertPinnedVerifier(policy);
-  const context = canonicalContext(message, config, policy, descriptor);
-  const recoveryBytes = optional[0]
-    ? privateBytes(paths.recovery, 65_536)
-    : null;
-  const recoveryBundle = optional[0]
-    ? privateBytes(paths.recoveryBundle, 1_048_576)
-    : null;
-  if (recoveryBytes) {
-    recoveryPermission(
-      policy,
-      descriptor,
-      context,
-      config,
-      bytes,
-      paths,
-      recoveryBytes,
-      recoveryBundle,
-      messageBytes
-    );
-  } else {
-    verifyDescriptorAttestation(policy, descriptor, paths, sha256(bytes));
-    verifyCurrentProvider(policy, descriptor);
-  }
+}
+
+/** Final rereads preserve the original mutation checks after all provider verification. */
+function verifyFinalSnapshot(
+  paths,
+  bundleBytes,
+  bytes,
+  descriptor,
+  messageFile,
+  reference,
+  policy
+) {
   requireProof(
     privateBytes(paths.bundle, 1_048_576).equals(bundleBytes),
     "origin bundle changed during verification"
@@ -148,17 +136,78 @@ export function verifyAutomationProvenance(messageFile) {
     reference,
     policy
   );
-  return true;
+}
+
+/** Verify fixed private proof against the final message, tree, binding and provider. */
+export function verifyAutomationProvenance(messageFile) {
+  const messageBytes = withProvenancePhase(LOCAL_PROOF, () =>
+    privateBytes(messageFile, 65_536, false)
+  );
+  const message = messageBytes.toString("utf8");
+  const reference = withProvenancePhase(LOCAL_PROOF, () =>
+    automationReference(message)
+  );
+  if (!reference) return false;
+  const { config, policy } = withProvenancePhase("configuration", () =>
+    trustedConfiguration(git)
+  );
+  const { paths, optional, bytes, bundleBytes, descriptor } =
+    withProvenancePhase(LOCAL_PROOF, proofSnapshot);
+  withProvenancePhase(LOCAL_PROOF, () =>
+    verifyLocalProposal(descriptor, messageBytes, reference, policy)
+  );
+  withProvenancePhase("verifier", () => assertPinnedVerifier(policy));
+  const context = withProvenancePhase("canonical-context", () =>
+    canonicalContext(message, config, policy, descriptor)
+  );
+  return withProvenancePhase("final-proof", () => {
+    const recoveryBytes = optional[0]
+      ? privateBytes(paths.recovery, 65_536)
+      : null;
+    const recoveryBundle = optional[0]
+      ? privateBytes(paths.recoveryBundle, 1_048_576)
+      : null;
+    if (recoveryBytes) {
+      withProvenancePhase("recovery-local", () =>
+        recoveryPermission(
+          policy,
+          descriptor,
+          context,
+          config,
+          bytes,
+          paths,
+          recoveryBytes,
+          recoveryBundle,
+          messageBytes
+        )
+      );
+    } else {
+      withProvenancePhase("ordinary-signature", () =>
+        verifyDescriptorAttestation(policy, descriptor, paths, sha256(bytes))
+      );
+      withProvenancePhase("ordinary-provider", () =>
+        verifyCurrentProvider(policy, descriptor)
+      );
+    }
+    verifyFinalSnapshot(
+      paths,
+      bundleBytes,
+      bytes,
+      descriptor,
+      messageFile,
+      reference,
+      policy
+    );
+    return true;
+  });
 }
 
 if (invokedAsScript(import.meta.url)) {
   try {
     const verified = verifyAutomationProvenance(process.argv[2]);
     process.exitCode = verified ? 0 : 10;
-  } catch {
-    console.error(
-      "Invalid automation provenance: required proof, policy or provider evidence failed"
-    );
+  } catch (error) {
+    console.error(provenanceFailure(error));
     process.exitCode = 1;
   }
 }

package/all/copy-overwrite/scripts/npm-updater-helper-graph.json

@@ -92,12 +92,13 @@
       "children": []
     },
     "lib/github-attestation-recovery.mjs": {
-      "sha256": "ff89d72300035a2554cf3e406b1054ca3c8a494d6a5768ea4981f4c87c50e981",
+      "sha256": "aa97fbc52f58aba1cc93e105a9ee7a32a0ae184259c10ab55e23589b593207f9",
       "staticImports": [
         "lib/automation-provenance-local.mjs",
         "lib/bounded-spawn.mjs",
         "lib/github-attestation-provider.mjs",
-        "lib/github-attestation-verifier.mjs"
+        "lib/github-attestation-verifier.mjs",
+        "lib/npm-update-invariants.mjs"
       ],
       "dynamicImports": [],
       "children": []
@@ -588,7 +589,7 @@
       "children": []
     },
     "lib/npm-update-hosted-gate.mjs": {
-      "sha256": "0c54442f27521c989783cdf5bf975739f99c9f46c8e67deee4da0eefb9b327b9",
+      "sha256": "b9ced911733ab9c6afd06c9451bb9d9cc9363e0a6fd1059ef659aba0107065cc",
       "staticImports": [
         "lib/npm-update-bun.mjs",
         "lib/npm-update-contract.mjs",
@@ -608,9 +609,10 @@
       "children": []
     },
     "lib/npm-update-hosted-hook.mjs": {
-      "sha256": "ef468e94c148b8d81125d3d374c2350b44abcb48ef9037639f0ba4a8ea9ecf03",
+      "sha256": "0e9cf3bf55b9b979d22553f01ad4d17c0a85058b2b87657bd3126b9034e9f8c1",
       "staticImports": [
         "lib/npm-update-contract.mjs",
+        "lib/npm-update-invariants.mjs",
         "lib/npm-update-isolation.mjs",
         "lib/npm-update-orchestrator.mjs",
         "lib/npm-update-process.mjs",
@@ -642,7 +644,7 @@
       ]
     },
     "lib/npm-update-invariants.mjs": {
-      "sha256": "136cb22396d33252494c4df1e35d13ff58c58a0ca34fbe5c68954b077cb3f30b",
+      "sha256": "e91f3f85bcce92eba8fb0a6a544a9ef3d60985828e6b8e5265e3d44e42bfe09b",
       "staticImports": [],
       "dynamicImports": [],
       "children": []
@@ -681,7 +683,7 @@
       "children": []
     },
     "lib/npm-update-native-process.mjs": {
-      "sha256": "295d69d90f32aad9d757060ea6d3f66787a00e24c19e01e5beaf2ba752fec8da",
+      "sha256": "1dec7d3392289203a99db38db1501a6282d436e779c720250aaf8fbfdd18bd16",
       "staticImports": [
         "lib/npm-update-contract.mjs",
         "lib/npm-update-invariants.mjs",
@@ -1124,13 +1126,14 @@
       "children": []
     },
     "lisa-automation-provenance.mjs": {
-      "sha256": "01bdecb447fe6ffa8e961846306a7839bce970e1a6ebacc9179e2d3cf662fce3",
+      "sha256": "d3d2ad9769b47ac988ff2bb4514ad37901cf5de854cf536cf1acf38fab9f94a0",
       "staticImports": [
         "lib/automation-provenance-contract.mjs",
         "lib/automation-provenance-local.mjs",
         "lib/github-attestation-recovery.mjs",
         "lib/github-attestation-verifier.mjs",
-        "lib/invoked-as-script.mjs"
+        "lib/invoked-as-script.mjs",
+        "lib/npm-update-invariants.mjs"
       ],
       "dynamicImports": [],
       "children": []

package/dist/core/lisa-owned-hash-ledger.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lisa-owned-hash-ledger.d.ts","sourceRoot":"","sources":["../../src/core/lisa-owned-hash-ledger.ts"],"names":[],"mappings":"AACA,6EAA6E;AAE7E;;;;;;;GAOG;AACH,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAC3C,MAAM,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC,CA09DjC,CAAC;AAEH;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,+BAA+B,EAAE,QAAQ,CACpD,MAAM,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC,CA63DjC,CAAC"}
+{"version":3,"file":"lisa-owned-hash-ledger.d.ts","sourceRoot":"","sources":["../../src/core/lisa-owned-hash-ledger.ts"],"names":[],"mappings":"AACA,6EAA6E;AAE7E;;;;;;;GAOG;AACH,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAC3C,MAAM,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC,CAi+DjC,CAAC;AAEH;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,+BAA+B,EAAE,QAAQ,CACpD,MAAM,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC,CAo4DjC,CAAC"}