@codyswann/lisa 4.73.8 → 4.74.0

package/README.md

@@ -186,7 +186,7 @@ any direct override in the current directory's `package.json`. It preserves the
 original error and does not change dependencies. Nested selectors and unreadable
 manifests remain unverified; this diagnostic is not a full lockfile audit.
 
-Clean TypeScript and CDK hosts receive the shared Node 22.23.3 baseline,
+Clean TypeScript and CDK hosts receive the shared Node 24.21.0 LTS baseline,
 Vitest and coverage-v8 4.1.11 minimums, and a Vite 8.3.2 minimum within Vite 8.
 Lisa retains the TypeScript 6, ESLint 9, Knip 5, Husky 8 and Vitest 4 families.
 New CDK hosts default to `aws-cdk-github-oidc ^5.2.0` with `constructs ^10.7.2`
@@ -204,11 +204,42 @@ lockfile alongside the host's test, typecheck and offline synth commands.
 Package template ownership still applies. Explicit TypeScript Node and test-tool
 `defaults` survive an apply, while CDK's `force` test tools advance to the shared
 patch floor. Existing create-only workflow and Expo EAS files stay host-owned.
-The overwritten `.nvmrc` supplies the shared Node runtime. Review older explicit
+The managed `.nvmrc` supplies the shared Node runtime. Known older Lisa copies
+advance with historical hash protection; unknown or newer custom bytes remain
+protected. `.lisaignore` keeps an intentional runtime override outside Lisa
+management. Review older explicit
 pins and create-only workflow inputs before adopting this baseline in an
 existing host. Maintainers can run `bun run update-node-version` after changing
 the root `.nvmrc` to update current tracked runtime surfaces without rewriting
-historical plans or generic test fixtures.
+historical plans or generic test fixtures. The npm updater has a separately
+qualified Node22.23.3 runtime, which this shared-default updater leaves alone.
+
+### Moving an existing host to Node24
+
+Review explicit `engines.node` and existing create-only workflow/EAS inputs;
+Lisa seeds missing values and preserves those existing host-owned choices.
+Remove `.nvmrc` from `.lisaignore` only when adopting Lisa's managed baseline.
+If an unknown custom `.nvmrc` is preserved, deliberately select that exact file
+with `lisa apply . --refresh-templates=.nvmrc`, then review the result. Run the
+host's install, typecheck, build and tests on the selected runtime before deploy.
+
+AWS Lambda `nodejs24.x` removes callback handlers and legacy context completion
+APIs, including `callbackWaitsForEmptyEventLoop`. Use supported async/await,
+synchronous-return or streaming forms; do not assign removed context properties.
+Earlier non-streaming async handlers already completed without waiting for
+unresolved promises. Node24 aligns streaming completion with that behavior:
+await required work before returning or ending the stream. Local Node execution
+does not prove deployed Lambda completion. See [AWS's runtime changes](https://aws.amazon.com/blogs/compute/node-js-24-runtime-now-available-in-aws-lambda/).
+
+For unwrapped scheduled, queue or Cognito handlers using Sentry, await a finite
+`Sentry.flush(timeoutMs)` on success and error paths. Handle false/rejected flush
+without replacing the original return value or thrown error; do not call
+`close()` per invocation, which disables the warm client. A compatible Sentry
+Lambda wrapper already flushes, by default for up to2000ms via `flushTimeout`.
+SDK compatibility matters: `@sentry/aws-serverless`11.6.0 still assigns the removed
+context property and cannot wrap a non-extensible context lacking it. The
+[SDK setup guidance](https://github.com/CodySwannGT/lisa/blob/main/plugins/src/base/skills/lisa-parity-sentry-sdk-setup/SKILL.md#node24-lambda-completion)
+includes the safe unwrapped pattern, wrapper limits and migration checks.
 
 When Lisa is invoked during installation it prints this next step. Package
 managers that do not run its lifecycle scripts cannot display that notice.
@@ -460,6 +491,24 @@ Rails consumers can follow the [test helper isolation and existing-consumer migr
 
 If you're changing Lisa itself: author agent content and templates at their source, never in generated output, and rebuild so the distributed artifacts regenerate. Lisa applies its own standards to itself, so the same gates that guard downstream projects guard this one — including the requirement to prove your change works.
 
+Lisa's main test suite runs on Node24.21.0. Its npm updater remains separately
+qualified on Node22.23.3, so unit coverage, push gates and the shell-guard tracer
+also need that real executable. On a Unix checkout using mise:
+
+```sh
+mise install node@22.23.3 node@24.21.0 bun@1.3.8 bun@1.3.11
+export LISA_TEST_UPDATER_NODE="$(mise where node@22.23.3)/bin/node"
+export LISA_TEST_HOST_BUN="$(mise where bun@1.3.11)/bin/bun"
+"$LISA_TEST_UPDATER_NODE" -p process.versions.node
+mise exec node@24.21.0 bun@1.3.8 -- bun run test:unit
+```
+
+The probe must print22.23.3; the fixtures verify its actual version and bytes.
+On macOS, select the short, non-symlink temp base `/private/tmp` before the
+native wrapper when running Unix-socket fixtures. Inherited Harper and Phaser
+native host checks also require their unchanged Bun1.3.11 floor; keep that
+host runtime distinct from Lisa's Bun1.3.8 tooling.
+
 > **Prompt for your coding agent**
 > "I want to add or change a skill, rule, hook, or agent in Lisa. Show me the source location, the build step, what I must commit alongside it, and the CI check that fails if I edit a generated artifact directly. Then check my change against those rules before I commit."
 

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;
   }
 }