@codyswann/lisa 4.71.2 → 4.71.4

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

@@ -0,0 +1,248 @@
+// This file is managed by Lisa and IS replaced on each `lisa` run.
+// Do not edit directly — durable changes belong upstream in Lisa.
+
+/** Explicit hosted manual cancellation preserves the old leaf and issues no publication authority. */
+import { join } from "node:path";
+import { writeFileSync } from "node:fs";
+import { canonicalJson } from "../lisa-automation-provenance.mjs";
+import { required, keys } from "./npm-update-contract.mjs";
+import { readBytes, readJson, writeJson } from "./npm-update-process.mjs";
+import { assertHostedGate } from "./npm-update-hosted-gate.mjs";
+import { sha256 } from "./github-attestation-verifier.mjs";
+import { discoverPrior } from "./npm-update-allocate.mjs";
+import { authenticateStaleOrigin } from "./npm-update-cancel-origin.mjs";
+import {
+  recordedCancellation,
+  cancellationDestinationAbsent,
+} from "./npm-update-supersession.mjs";
+import {
+  assertManualCancellation,
+  cancellationRecord,
+  validateCancellation,
+  verifyCancellationAttestation,
+} from "./npm-update-cancellation-proof.mjs";
+import {
+  persistCheckpoint,
+  decodeCheckpoint,
+} from "./npm-update-checkpoint.mjs";
+import { withStage } from "./npm-update-invariants.mjs";
+
+/** Native dispatch bytes are checked independently of reusable workflow input forwarding. */
+export function assertDispatchCancellation(event, run, request, authority) {
+  required(
+    event &&
+      ["main", "refs/heads/main"].includes(event.ref) &&
+      event.repository?.full_name === authority.repository &&
+      String(event.repository.id) === authority.repositoryId &&
+      String(event.repository.owner?.id) === authority.ownerId &&
+      event.sender?.type === "User" &&
+      event.sender.id === run.triggering_actor?.id &&
+      event.sender.login === run.triggering_actor.login &&
+      event.inputs?.cancel_issue === String(request.number) &&
+      event.inputs.cancel_proposal_key === request.proposalKey &&
+      event.inputs.cancel_expected_main === request.parent,
+    "native manual dispatch intent differs"
+  );
+}
+
+/** The actual run and repository permission are read through the existing pinned default-token transport. */
+async function manualAuthority(api, proposal, config, request) {
+  assertHostedGate({ policy: config.npmUpdater, proposal, config });
+  const invocation = {
+    runId: process.env.GITHUB_RUN_ID,
+    runAttempt: process.env.GITHUB_RUN_ATTEMPT,
+  };
+  required(
+    Object.values(invocation).every(
+      value => typeof value === "string" && /^[1-9]\d*$/.test(value)
+    ),
+    "native cancellation invocation is absent"
+  );
+  await api.main(proposal.parent);
+  const run = await api.request(
+    `repos/${proposal.repository}/actions/runs/${invocation.runId}/attempts/${invocation.runAttempt}`
+  );
+  const permission = await api.request(
+    `repos/${proposal.repository}/collaborators/${config.npmUpdater.maintainer}/permission`
+  );
+  const operatorId = assertManualCancellation(
+    run,
+    permission,
+    api.policy,
+    config.npmUpdater.maintainer,
+    proposal,
+    request,
+    invocation
+  );
+  const event = JSON.parse(
+    new TextDecoder("utf8", { fatal: true }).decode(
+      readBytes(process.env.GITHUB_EVENT_PATH, 1_048_576, false)
+    )
+  );
+  assertDispatchCancellation(event, run, request, api.policy);
+  return { invocation, operatorId };
+}
+
+/** Named stale origins are never substituted by a closed implementation ticket or another active leaf. */
+async function cancellationState(context) {
+  const { api, cwd, proposal, config, request } = context;
+  const manual = await withStage("cancel-intent", () =>
+    manualAuthority(api, proposal, config, request)
+  );
+  const prior = await discoverPrior(api, proposal, { cwd, config });
+  const issue = await api.issue(request.number);
+  const origin = await withStage("cancel-origin", () =>
+    authenticateStaleOrigin({ api, cwd, issue, proposal, config })
+  );
+  required(
+    origin.proposal.key === request.proposalKey,
+    "named original proposal differs"
+  );
+  await cancellationDestinationAbsent(api, request.proposalKey);
+  const recorded = await recordedCancellation({
+    api,
+    cwd,
+    issue,
+    proposal,
+    config,
+    origin,
+  });
+  if (recorded) {
+    const record = recorded.payload.preview.cancellation;
+    required(
+      record.parent === proposal.parent &&
+        record.proposalKey === proposal.key &&
+        canonicalJson(record.proposalHashes) === canonicalJson(proposal.hashes),
+      "recorded replacement no longer matches"
+    );
+  } else
+    required(
+      issue.state === "open" &&
+        prior.status === "stale-outstanding" &&
+        prior.issue.number === request.number,
+      "only the active stale origin can be cancelled"
+    );
+  return { ...manual, issue, origin, recorded };
+}
+
+/** Preparation writes only a private prospective subject, never a provider lifecycle mutation. */
+export async function prepareCancellation(context) {
+  const { output, proposal, config, request } = context;
+  const state = await cancellationState(context);
+  const record =
+    state.recorded?.payload.preview.cancellation ??
+    cancellationRecord(
+      state.origin,
+      proposal,
+      config,
+      state.invocation,
+      state.operatorId
+    );
+  validateCancellation(record, record);
+  writeJson(join(output, "cancellation.json"), record);
+  const mode = state.recorded ? "recorded" : "fresh";
+  if (state.recorded) {
+    const bytes = Buffer.from(state.recorded.payload.bundle);
+    required(bytes.length <= 1_048_576, "cancellation bundle exceeds bound");
+    writeFileSync(join(output, "cancellation-bundle.json"), bytes, {
+      mode: 0o600,
+      flag: "wx",
+    });
+  }
+  writeJson(join(output, "cancellation-state.json"), { mode, request });
+  return { mode };
+}
+
+/** Each chunk and closure rechecks current operator, main, holds, destination and immutable subject. */
+async function authorizeCancellation(context, record, paths, state) {
+  const current = await cancellationState(context);
+  if (state.mode === "fresh") {
+    validateCancellation(
+      record,
+      cancellationRecord(
+        current.origin,
+        context.proposal,
+        context.config,
+        current.invocation,
+        current.operatorId
+      )
+    );
+    verifyCancellationAttestation(
+      context.api.policy,
+      record,
+      paths,
+      sha256(readBytes(paths.cancellation, 65_536))
+    );
+  } else
+    required(
+      state.mode === "recorded" &&
+        current.recorded &&
+        canonicalJson(current.recorded.payload.preview.cancellation) ===
+          canonicalJson(record),
+      "recorded cancellation authority differs"
+    );
+  return current;
+}
+
+/** Durable proof precedes a not_planned close; interruptions retain all evidence for the next manual run. */
+export async function finalizeCancellation(context) {
+  const { api, output, proposal, request } = context;
+  const state = readJson(join(output, "cancellation-state.json"), 65_536);
+  keys(state, ["mode", "request"]);
+  required(
+    canonicalJson(state.request) === canonicalJson(request),
+    "cancellation intent changed"
+  );
+  const paths = {
+    cancellation: join(output, "cancellation.json"),
+    cancellationBundle: join(output, "cancellation-bundle.json"),
+  };
+  const record = readJson(paths.cancellation, 65_536);
+  const digest = sha256(readBytes(paths.cancellation, 65_536));
+  const current = await authorizeCancellation(context, record, paths, state);
+  const payload = current.recorded?.payload ?? {
+    version: 1,
+    proposal,
+    allocation: current.origin.allocation,
+    preview: { cancellation: record },
+    bundle: readBytes(paths.cancellationBundle, 1_048_576).toString("utf8"),
+  };
+  if (!current.recorded)
+    await withStage("cancel-checkpoint", () =>
+      persistCheckpoint(api, request.number, payload, digest, () =>
+        authorizeCancellation(context, record, paths, state)
+      )
+    );
+  const issue = (await authorizeCancellation(context, record, paths, state))
+    .issue;
+  required(
+    canonicalJson(decodeCheckpoint(issue.comments, digest)) ===
+      canonicalJson(payload),
+    "durable cancellation checkpoint differs"
+  );
+  if (issue.state === "open")
+    await withStage("cancel-close", () =>
+      api.request(
+        `repos/${proposal.repository}/issues/${request.number}`,
+        "PATCH",
+        { state: "closed", state_reason: "not_planned" }
+      )
+    );
+  const closed = await api.issue(request.number);
+  required(
+    closed.state === "closed" &&
+      closed.state_reason === "not_planned" &&
+      closed.closed_by?.type === "Bot" &&
+      String(closed.closed_by.id) === api.policy.claimActorId &&
+      closed.body === issue.body &&
+      closed.title === issue.title,
+    "cancellation closure readback differs"
+  );
+  await api.main(proposal.parent);
+  await cancellationDestinationAbsent(api, request.proposalKey);
+  return {
+    status: "cancelled",
+    number: request.number,
+    cancellationSha256: digest,
+  };
+}

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

@@ -0,0 +1,94 @@
+// This file is managed by Lisa and IS replaced on each `lisa` run.
+// Do not edit directly — durable changes belong upstream in Lisa.
+
+/** One invocation reuses authenticated code bytes, never mutable provider authorization. */
+import { required, OBJECT } from "./npm-update-contract.mjs";
+
+/** Fresh owner selection and regular-file reads precede every cached use. */
+function currentBinding(config, owner, read, members) {
+  const selected = owner();
+  return {
+    root: selected.root,
+    source: selected.source,
+    version: selected.metadata.version,
+    signerDigest: config.automationProvenance?.signerDigest,
+    bytes: read(selected.root, members),
+  };
+}
+
+/** A cached import URL cannot authorize changed files or a replacement owner. */
+function assertBinding(expected, actual) {
+  required(
+    ["root", "source", "version", "signerDigest"].every(
+      field => expected[field] === actual[field]
+    ) &&
+      expected.bytes.length === actual.bytes.length &&
+      expected.bytes.every((bytes, index) => bytes.equals(actual.bytes[index])),
+    "authenticated classifier identity or bytes changed"
+  );
+}
+
+/** A sibling awaiting the same import may have invalidated its URL meanwhile. */
+function assertUsable(poisoned, ...roots) {
+  required(
+    roots.every(root => !poisoned.has(root)),
+    "authenticated classifier import lifetime is uncertain"
+  );
+}
+
+/** Each factory owns its inaccessible cache; another caller cannot preseed this instance. */
+export function classifierMemo(owner, read, members) {
+  const entries = new WeakMap();
+  const poisoned = new Set();
+  const fixed = [...members];
+  return async (config, authenticate) => {
+    const current = currentBinding(config, owner, read, fixed);
+    assertUsable(poisoned, current.root);
+    // Without a source pin, the original qualifier must observe current HEAD each time.
+    if (
+      current.source &&
+      (typeof current.signerDigest !== "string" ||
+        !OBJECT.test(current.signerDigest))
+    ) {
+      const imported = await authenticate();
+      const observed = currentBinding(config, owner, read, fixed);
+      assertUsable(poisoned, current.root, imported.root, observed.root);
+      return imported.verdict;
+    }
+    let entry = entries.get(config);
+    if (entry) assertBinding(entry.binding, current);
+    else {
+      entry = {
+        binding: {
+          ...current,
+          bytes: current.bytes.map(bytes => Buffer.from(bytes)),
+        },
+        promise: Promise.resolve().then(authenticate),
+      };
+      entries.set(config, entry);
+      const pending = entry;
+      pending.promise.catch(() => {
+        if (entries.get(config) === pending) entries.delete(config);
+      });
+    }
+    const imported = await entry.promise;
+    let observed;
+    try {
+      // Authentication/import may yield; detect changes during that interval too.
+      observed = currentBinding(config, owner, read, fixed);
+      assertBinding(entry.binding, observed);
+      required(
+        imported.root === entry.binding.root,
+        "classifier import owner changed"
+      );
+      assertUsable(poisoned, entry.binding.root, imported.root, observed.root);
+    } catch (error) {
+      // ESM caches this URL: restoring files or another config cannot requalify it.
+      poisoned.add(entry.binding.root);
+      poisoned.add(imported.root);
+      if (observed) poisoned.add(observed.root);
+      throw error;
+    }
+    return imported.verdict;
+  };
+}

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

@@ -42,7 +42,11 @@ const PRODUCER = [
   "allocate",
   "authorization",
   "broker-client",
+  "cancel-origin",
+  "cancellation",
+  "cancellation-proof",
   "checkpoint",
+  "classifier-cache",
   "contract",
   "controller-broker",
   "controller-factory",
@@ -81,6 +85,7 @@ const PRODUCER = [
   "publish",
   "quality",
   "recovery",
+  "supersession",
   "runtime-archive",
   "runtime-graph",
   "runtime-transport",

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

@@ -8,6 +8,7 @@ import { join } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { existsSync, lstatSync, realpathSync } from "node:fs";
 import { required, VERSION, OBJECT } from "./npm-update-contract.mjs";
+import { classifierMemo } from "./npm-update-classifier-cache.mjs";
 import {
   readBytes,
   runProcess,
@@ -33,6 +34,7 @@ import {
 } from "./npm-update-helper-graph.mjs";
 
 const PACKAGE = "@codyswann/lisa";
+const classifier = classifierMemo(helperOwner, helperBytes, MEMBERS);
 
 /** Native package resolution supports both upstream and actual emitted managed layouts. */
 export function helperOwner() {
@@ -277,7 +279,7 @@ export async function qualifiedControllerGraph(cwd, config, entries) {
 }
 
 /** No canonical package code is imported until independent authority qualifies its fixed graph. */
-export async function canonicalClassifier(config) {
+async function authenticatedClassifier(config) {
   const owner = await qualifiedHelperFiles(config, MEMBERS);
   required(
     classifierGraphMatches(MEMBERS.map(member => owner.bytes.get(member))),
@@ -288,5 +290,10 @@ export async function canonicalClassifier(config) {
     typeof module.humanGateVerdict === "function",
     "canonical hold classifier is unavailable"
   );
-  return module.humanGateVerdict;
+  return { root: owner.root, verdict: module.humanGateVerdict };
+}
+
+/** Current bytes must still match the independently authenticated imported closure. */
+export function canonicalClassifier(config) {
+  return classifier(config, () => authenticatedClassifier(config));
 }

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

@@ -4,6 +4,10 @@
 /** Pure shared diagnostics retain one error identity without importing producer orchestration. */
 const stages = new Set([
   "configuration",
+  "cancel-intent",
+  "cancel-origin",
+  "cancel-checkpoint",
+  "cancel-close",
   "gate-input",
   "gate-validate",
   "gate-scratch",

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

@@ -142,7 +142,7 @@ Git history command: ${evidence.history.command}
 Git history outcome: ${evidence.history.result}
 All-state GitHub query: ${evidence.search.query}
 Outcome: every matching record was loaded completely; unrelated work was preserved and exact proposal recovery was checked separately.
-Matches are read completely before allocating this deterministic proposal. No parent or PRD lineage is declared; this build-ready standalone Task is one leaf.
+Matches are read completely before allocating this deterministic proposal. No parent or PRD lineage is declared; this build-ready standalone Task is one leaf.${evidence.supersession ? `\nSupersedes cancelled proposal ${evidence.supersession.workItem}. Original proposal key: ${evidence.supersession.proposalKey}. Verified cancellation SHA256: ${evidence.supersession.cancellationSha256}. The previous claim, specification and checkpoint are preserved; this leaf has fresh parent-bound authority.` : ""}
 
 ## Validation Journey
 

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

@@ -82,12 +82,29 @@ export async function claimLeaf(
 
 /** Complete provider history and immutable human policy govern every mutation. */
 export async function inspectLeaf(issue, draft, policy, config) {
-  const roles = leafRoles(config, policy.repository);
-  const labels = issue.labels.map(label => label.name);
   required(
     issue.state === "open" && !issue.pull_request && issue.number > 0,
     "closed or nonissue leaf"
   );
+  return inspectLeafFields(issue, draft, policy, config);
+}
+
+/** Closed-state inspection never grants authority without a separately verified cancellation. */
+export async function inspectCancelledLeaf(issue, draft, policy, config) {
+  required(
+    issue.state === "closed" &&
+      issue.state_reason === "not_planned" &&
+      !issue.pull_request &&
+      issue.number > 0,
+    "leaf is not explicitly cancelled"
+  );
+  return inspectLeafFields(issue, draft, policy, config);
+}
+
+/** Both fixed state entry points preserve the original complete ownership and hold checks. */
+async function inspectLeafFields(issue, draft, policy, config) {
+  const roles = leafRoles(config, policy.repository);
+  const labels = issue.labels.map(label => label.name);
   required(
     issue.children.length === 0 &&
       issue.blockers.every(item => item.state === "closed"),
@@ -151,7 +168,16 @@ export function historicalFiling(issue) {
   const value = JSON.parse(
     new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(bytes)
   );
-  keys(value, ["history", "search", "registry", "labels", "main"]);
+  keys(value, [
+    "history",
+    "search",
+    "registry",
+    "labels",
+    "main",
+    ...(value.supersession ? ["supersession"] : []),
+  ]);
+  if (value.supersession)
+    keys(value.supersession, ["workItem", "cancellationSha256", "proposalKey"]);
   required(
     canonicalJson(value) === bytes.toString("utf8"),
     "original filing fields are noncanonical"