@codyswann/lisa 4.70.3 → 4.71.0

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

@@ -27,6 +27,7 @@ import {
   gitRead,
   HistorySecretError,
 } from "./history-secret-git.mjs";
+import { classifyEvidence } from "./history-secret-evidence.mjs";
 
 export const VERSION = "8.30.1";
 /** Archive and extracted executable pins both come from the same official release. */
@@ -222,303 +223,12 @@ export const qualifyScanner = requested => {
   return binary;
 };
 
-const EVIDENCE_BUDGET = 64 * 1024 * 1024;
-const NO_REPLACEMENTS = "--no-replace-objects";
-const TAXONOMY = "Disk/missing/corrupt";
-const NARRATIVE = [
-  "AccessDenied boundaries,",
-  `${TAXONOMY} falsifications.`,
-].join(" ");
-const safePath = value =>
-  typeof value === "string" &&
-  value.length > 0 &&
-  !/[\\\u0000-\u001f\u007f]/u.test(value) &&
-  !/^(?:\/|[A-Za-z]:)/u.test(value) &&
-  value.split("/").every(part => part && part !== "." && part !== "..");
-
-/** Read authentic regular Git blobs, never trimmed text or worktree evidence. */
-const readBlob = (file, commit, cwd, budget) => {
-  if (!safePath(file)) return null;
-  const entries = gitRead(
-    ["--literal-pathspecs", "ls-tree", "-z", commit, "--", file],
-    cwd
-  )
-    .split("\0")
-    .filter(Boolean);
-  if (entries.length !== 1) return null;
-  const entry = entries[0].match(
-    /^(100644|100755) blob ([a-f0-9]{40}|[a-f0-9]{64})\t([\s\S]*)$/u
-  );
-  if (!entry || entry[3] !== file || entry[2].length !== commit.length)
-    return null;
-  const sizeText = gitRead(["cat-file", "-s", entry[2]], cwd);
-  const size = Number(sizeText);
-  if (!/^\d+$/u.test(sizeText) || !Number.isSafeInteger(size))
-    throw new HistorySecretError(
-      "Git blob size is invalid. Repair complete Git objects and retry; safety is unproved."
-    );
-  if (size > budget.remaining) return null;
-  const result = spawnSync(
-    "git",
-    [NO_REPLACEMENTS, "cat-file", "blob", entry[2]],
-    {
-      cwd,
-      env: gitEnvironment(),
-      timeout: 120000,
-      maxBuffer: EVIDENCE_BUDGET,
-    }
-  );
-  if (
-    result.error ||
-    result.signal ||
-    result.status !== 0 ||
-    result.stdout.length !== size ||
-    createHash(commit.length === 40 ? "sha1" : "sha256")
-      .update(`blob ${size}\0`)
-      .update(result.stdout)
-      .digest("hex") !== entry[2]
-  )
+/** Only structured safe attribution is serialized, never stderr or metadata strings. */
+export const scanCommits = (commits, cwd, requested, heads = []) => {
+  if (!Array.isArray(heads) || heads.some(head => !commits.includes(head)))
     throw new HistorySecretError(
-      "Git blob bytes cannot be verified. Repair complete Git objects and retry; no raw source is published."
+      "Evidence heads are not actual introduced commits. Supply original Git input and retry."
     );
-  budget.remaining -= size;
-  return result.stdout;
-};
-
-/** Native JSON validation plus bounded duplicate-aware lexical role attribution. */
-const evidenceMap = bytes => {
-  if (bytes.length > 1024 * 1024) return null;
-  const text = bytes.toString("utf8");
-  if (!Buffer.from(text).equals(bytes)) return null;
-  try {
-    const value = JSON.parse(text);
-    if (
-      !value ||
-      typeof value !== "object" ||
-      Array.isArray(value) ||
-      !value.source_sha256 ||
-      typeof value.source_sha256 !== "object" ||
-      Array.isArray(value.source_sha256)
-    )
-      return null;
-    const entries = Object.entries(value.source_sha256);
-    if (
-      !entries.length ||
-      entries.length > 256 ||
-      entries.some(
-        ([file, hash]) =>
-          !safePath(file) ||
-          typeof hash !== "string" ||
-          !/^[a-f0-9]{64}$/u.test(hash)
-      )
-    )
-      return null;
-    const tokens = [
-      ...text.matchAll(/"(?:\\[\s\S]|[^"\\])*"|[{}[\],:]|[^{}[\],:\s]+/gu),
-    ];
-    if (tokens.length > 8192) return null;
-    let cursor = 0;
-    const spans = [];
-    const visit = (path, depth) => {
-      if (depth > 32) throw new Error("Bounded JSON depth");
-      const token = tokens[cursor++];
-      if (token[0] === "{") {
-        const keys = new Set();
-        while (tokens[cursor][0] !== "}") {
-          const key = JSON.parse(tokens[cursor++][0]);
-          if (keys.has(key)) throw new Error("Duplicate decoded JSON key");
-          keys.add(key);
-          cursor++; // Native JSON validation already proved the colon.
-          visit([...path, key], depth + 1);
-          if (tokens[cursor][0] === ",") cursor++;
-        }
-        cursor++;
-      } else if (token[0] === "[") {
-        let index = 0;
-        while (tokens[cursor][0] !== "]") {
-          visit([...path, index++], depth + 1);
-          if (tokens[cursor][0] === ",") cursor++;
-        }
-        cursor++;
-      } else if (
-        path.length === 2 &&
-        path[0] === "source_sha256" &&
-        token[0][0] === '"'
-      ) {
-        const hash = JSON.parse(token[0]);
-        // Escaped values do not supply an unambiguous literal detector span.
-        if (token[0] !== JSON.stringify(hash))
-          throw new Error("Ambiguous digest spelling");
-        spans.push({
-          file: path[1],
-          hash,
-          start: Buffer.byteLength(text.slice(0, token.index + 1)),
-          end: Buffer.byteLength(
-            text.slice(0, token.index + token[0].length - 1)
-          ),
-        });
-      }
-    };
-    visit([], 0);
-    return cursor === tokens.length && spans.length === entries.length
-      ? { value, spans }
-      : null;
-  } catch {
-    // probe-direction: fail-closed — malformed, duplicate or over-budget JSON
-    // cannot establish evidence role; its detector findings remain blocking.
-    return null;
-  }
-};
-
-/** Clear only a uniquely attributed, independently established benign finding. */
-const classifyEvidence = cwd => {
-  const budget = { remaining: EVIDENCE_BUDGET };
-  const blobs = new Map();
-  const maps = new Map();
-  const blob = (file, commit) => {
-    const key = `${commit}\0${file}`;
-    if (!blobs.has(key)) {
-      if (blobs.size >= 256) return null;
-      blobs.set(key, readBlob(file, commit, cwd, budget));
-    }
-    return blobs.get(key);
-  };
-  return row => {
-    if (
-      row.RuleID !== "generic-api-key" ||
-      !safePath(row.File) ||
-      row.SymlinkFile !== "" ||
-      row.Secret !== "REDACTED" ||
-      typeof row.Match !== "string" ||
-      row.EndLine !== row.StartLine ||
-      !Number.isSafeInteger(row.StartColumn) ||
-      !Number.isSafeInteger(row.EndColumn) ||
-      row.StartColumn < 1 ||
-      row.EndColumn < row.StartColumn
-    )
-      return false;
-    const bytes = blob(row.File, row.Commit);
-    if (!bytes) return false;
-    let lineStart = 0;
-    for (let line = 1; line < row.StartLine; line++) {
-      const next = bytes.indexOf(10, lineStart);
-      if (next < 0) return false;
-      lineStart = next + 1;
-    }
-    const newline = bytes.indexOf(10, lineStart);
-    const lineEnd = newline < 0 ? bytes.length : newline;
-    const replacements = row.Match.split("REDACTED");
-    if (replacements.length !== 2) return false;
-    const line = bytes.subarray(lineStart, lineEnd);
-    const attributed = (candidate, left, right) => {
-      const template = replacements.join(candidate);
-      if (template.split(candidate).length !== 2) return false;
-      const original = Buffer.from(template);
-      const offset = line.indexOf(original);
-      if (offset < 0 || line.indexOf(original, offset + 1) >= 0) return false;
-      const start = lineStart + offset;
-      const end = start + original.length;
-      if (
-        left !== start + Buffer.byteLength(replacements[0]) ||
-        right !== left + Buffer.byteLength(candidate)
-      )
-        return false;
-      // Pinned 8.30.1 detect/location.go counts a preceding fragment newline
-      // in columns after its first line. Prove exactly one of those two byte
-      // frames against the actual unique Git span; never infer fragment state.
-      return (
-        [0, 1].filter(
-          newlineByte =>
-            start === lineStart + row.StartColumn - 1 - newlineByte &&
-            end === lineStart + row.EndColumn - newlineByte
-        ).length === 1
-      );
-    };
-    // A complete standalone validation paragraph excludes surrounding JSON,
-    // assignments and interpolated/code contexts, not merely their filenames.
-    if (
-      (bytes.equals(Buffer.from(NARRATIVE)) ||
-        bytes.equals(Buffer.from(`${NARRATIVE}\n`))) &&
-      attributed(
-        TAXONOMY,
-        NARRATIVE.indexOf(TAXONOMY),
-        NARRATIVE.indexOf(TAXONOMY) + TAXONOMY.length
-      )
-    )
-      return true;
-    const key = `${row.Commit}\0${row.File}`;
-    if (!maps.has(key)) {
-      const parsed = evidenceMap(bytes);
-      let valid = parsed !== null;
-      const revision =
-        parsed && Object.hasOwn(parsed.value, "source_revision")
-          ? parsed.value.source_revision
-          : row.Commit;
-      if (parsed && Object.hasOwn(parsed.value, "source_revision")) {
-        valid =
-          typeof revision === "string" &&
-          new RegExp(`^[a-f0-9]{${row.Commit.length}}$`, "u").test(revision);
-        if (valid) {
-          const type = spawnSync(
-            "git",
-            [NO_REPLACEMENTS, "cat-file", "-t", revision],
-            {
-              cwd,
-              env: gitEnvironment(),
-              timeout: 120000,
-              maxBuffer: 1024 * 1024,
-            }
-          );
-          const ancestry = spawnSync(
-            "git",
-            [
-              NO_REPLACEMENTS,
-              "merge-base",
-              "--is-ancestor",
-              revision,
-              row.Commit,
-            ],
-            {
-              cwd,
-              env: gitEnvironment(),
-              timeout: 120000,
-              maxBuffer: 1024 * 1024,
-            }
-          );
-          // probe-direction: fail-closed — an absent/unreachable revision or
-          // failed ancestry probe cannot establish a historical preimage.
-          valid =
-            !type.error &&
-            !type.signal &&
-            type.status === 0 &&
-            type.stdout.toString() === "commit\n" &&
-            !type.stderr.length &&
-            !ancestry.error &&
-            !ancestry.signal &&
-            ancestry.status === 0 &&
-            !ancestry.stdout.length &&
-            !ancestry.stderr.length;
-        }
-      }
-      if (valid)
-        for (const span of parsed.spans) {
-          const sourceBytes = blob(span.file, revision);
-          if (!sourceBytes || digest(sourceBytes) !== span.hash) {
-            valid = false;
-            break;
-          }
-        }
-      maps.set(key, valid ? parsed.spans : []);
-    }
-    const candidates = maps
-      .get(key)
-      .filter(span => attributed(span.hash, span.start, span.end));
-    return candidates.length === 1;
-  };
-};
-
-/** Only structured safe attribution is serialized, never stderr or metadata strings. */
-export const scanCommits = (commits, cwd, requested) => {
   const binary = qualifyScanner(requested);
   const scratch = mkdtempSync(join(tmpdir(), "lisa-history-scan-"));
   chmodSync(scratch, 0o700);
@@ -558,7 +268,7 @@ export const scanCommits = (commits, cwd, requested) => {
     });
     const findings = [];
     const audit = auditedGit(scratch);
-    const benign = classifyEvidence(cwd);
+    const benign = classifyEvidence(cwd, commits, [...new Set(heads)]);
     for (let offset = 0; offset < commits.length; offset += 100) {
       const group = commits.slice(offset, offset + 100);
       audit.begin();

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

@@ -0,0 +1,289 @@
+// This file is managed by Lisa and IS replaced on each `lisa` run.
+// Do not edit directly — durable changes belong upstream in Lisa.
+
+/** Fixed-schema writer evidence and idempotent current claim. @module npm-updater */
+import { required, CLAIM, validateProposal } from "./npm-update-contract.mjs";
+import { baseline } from "./npm-update-prepare.mjs";
+import { locateCheckpoint } from "./npm-update-recovery.mjs";
+import { runProcess } from "./npm-update-process.mjs";
+import { sha256 } from "./github-attestation-verifier.mjs";
+import { registryVersion } from "./npm-update-npm.mjs";
+import {
+  buildDraft,
+  qualityGates,
+  inspectLeaf,
+  leafRoles,
+  historicalFiling,
+  claimLeaf,
+} from "./npm-update-leaf.mjs";
+/** Probe the named surfaces, all-state relationships and committed history before filing. */
+export async function filingEvidence(api, proposal, config, cwd) {
+  await baseline(
+    cwd,
+    { PATH: process.env.PATH, HOME: "/nonexistent", GIT_TERMINAL_PROMPT: "0" },
+    proposal
+  );
+  await api.main(proposal.parent);
+  const query = `repo:${proposal.repository} npm is:issue in:title,body`;
+  const search = await api.request(
+    `search/issues?q=${encodeURIComponent(query)}&per_page=100`
+  );
+  required(
+    !search.incomplete_results && search.total_count <= 100,
+    "relationship search is incomplete or oversized"
+  );
+  for (const item of search.items) await api.issue(item.number);
+  const history = await runProcess(
+    "git",
+    [
+      "log",
+      proposal.parent,
+      "--max-count=20",
+      "--format=%H %s",
+      "--",
+      "package.json",
+      "package-lock.json",
+    ],
+    {
+      cwd,
+      env: {
+        PATH: process.env.PATH,
+        HOME: "/nonexistent",
+        GIT_TERMINAL_PROMPT: "0",
+      },
+    }
+  );
+  const registry = [];
+  for (const update of proposal.updates)
+    registry.push(await registryVersion(update, proposal));
+  const labels = (await api.list(`repos/${proposal.repository}/labels`)).map(
+    label => label.name
+  );
+  return {
+    history: {
+      command: `git log ${proposal.parent} --max-count=20 -- package.json package-lock.json`,
+      result: history.stdout.toString() || "No matching history.",
+    },
+    search: { query, total: search.total_count },
+    registry,
+    labels,
+    main: proposal.parent,
+  };
+}
+
+/** Same selected versions are discovered before deriving a new parent-bound key. */
+export async function discoverPrior(api, proposal) {
+  const query = `repo:${proposal.repository} "${proposal.selectionKey}" is:issue in:body`;
+  const found = await api.request(
+    `search/issues?q=${encodeURIComponent(query)}&per_page=100`
+  );
+  required(
+    found.incomplete_results === false &&
+      Number.isSafeInteger(found.total_count) &&
+      found.total_count <= 1 &&
+      Array.isArray(found.items) &&
+      found.items.length === found.total_count,
+    "prior selection search is incomplete or ambiguous"
+  );
+  if (!found.total_count) return { status: "new" };
+  const issue = await api.issue(found.items[0].number);
+  required(
+    issue.state === "open" &&
+      !issue.pull_request &&
+      typeof issue.body === "string",
+    "closed or foreign prior proposal is preserved"
+  );
+  const selected = [
+    ...issue.body.matchAll(/^Selection key: ([a-f0-9]{64})$/gm),
+  ];
+  const parents = [...issue.body.matchAll(/^Base parent: ([a-f0-9]{40})$/gm)];
+  required(
+    selected.length === 1 &&
+      selected[0][1] === proposal.selectionKey &&
+      parents.length === 1,
+    "prior proposal identity differs"
+  );
+  return {
+    status:
+      parents[0][1] === proposal.parent ? "existing" : "stale-outstanding",
+    issue,
+  };
+}
+
+/** Restoration preserves original filing bytes while checking the live claim and holds. */
+async function restoredAllocation({
+  api,
+  proposal,
+  policy,
+  config,
+  prior,
+  checkpoint,
+  evidence,
+  currentEvidence,
+}) {
+  if (prior.issue) {
+    const state = await inspectLeaf(
+      prior.issue,
+      buildDraft(proposal, policy, config, evidence),
+      policy,
+      config
+    );
+    if (checkpoint?.signed) {
+      const allocation = checkpoint.payload.allocation;
+      required(
+        state.claimed &&
+          !state.unassigned &&
+          state.claims.length === 1 &&
+          String(state.claims[0].id) === allocation.claimCommentId &&
+          sha256(state.claims[0].body) === allocation.claimSha256 &&
+          String(state.claims[0].user?.id) === api.policy.claimActorId &&
+          state.claims[0].user?.type === "Bot",
+        "origin checkpoint current claim changed"
+      );
+      qualityGates(
+        {
+          ...allocation.draft,
+          title: prior.issue.title,
+          body: prior.issue.body,
+        },
+        proposal,
+        policy,
+        config,
+        evidence
+      );
+      return { ...allocation, currentEvidence, origin: checkpoint };
+    }
+  }
+}
+
+/** Missing configured lifecycle labels are provisioned before the fresh fixed draft. */
+async function ensureLabels({
+  api,
+  policy,
+  roles,
+  currentEvidence,
+  prior,
+  evidence,
+}) {
+  for (const name of [
+    "type:Task",
+    "priority:medium",
+    roles.ready,
+    roles.claimed,
+  ]) {
+    if (!currentEvidence.labels.includes(name)) {
+      await api.request(`repos/${policy.repository}/labels`, "POST", {
+        name,
+        color: "ededed",
+        description: "Managed dependency Task lifecycle",
+      });
+      currentEvidence.labels.push(name);
+      if (!prior.issue) evidence.labels = currentEvidence.labels;
+    }
+  }
+}
+
+/** The shipped claim and post-write quality check complete one canonical leaf. */
+async function completeAllocation({
+  api,
+  proposal,
+  policy,
+  config,
+  prior,
+  evidence,
+  currentEvidence,
+  roles,
+}) {
+  const draft = buildDraft(proposal, policy, config, evidence);
+  const before = qualityGates(draft, proposal, policy, config, evidence);
+  let issue =
+    prior.issue ??
+    (await api.request(`repos/${policy.repository}/issues`, "POST", {
+      title: draft.title,
+      body: draft.body,
+      labels: draft.labels,
+      assignees: draft.assignees,
+    }));
+  const claimed = await claimLeaf(
+    api,
+    issue,
+    draft,
+    proposal,
+    policy,
+    config,
+    evidence,
+    roles
+  );
+  issue = claimed.issue;
+  const state = claimed.state;
+  const after = qualityGates(
+    { ...draft, title: issue.title, body: issue.body },
+    proposal,
+    policy,
+    config,
+    evidence
+  );
+  const announcement = `[${policy.repository.split("/")[1]}] Fresh dependency Task ${policy.repository}#${issue.number} is assigned to ${policy.maintainer}. Proposal key: ${proposal.key}. Pre/post writer quality gates completed; ordinary gates and runtime evidence remain required.`;
+  if (!issue.comments.some(comment => comment.body === announcement))
+    await api.request(
+      `repos/${policy.repository}/issues/${issue.number}/comments`,
+      "POST",
+      { body: announcement }
+    );
+  return {
+    number: issue.number,
+    workItem: `${policy.repository}#${issue.number}`,
+    claimCommentId: String(state.claims[0].id),
+    claimSha256: sha256(CLAIM),
+    draft,
+    evidence,
+    quality: { before, after },
+    currentEvidence,
+    originalProposal: proposal,
+  };
+}
+
+/** Fixed writer pre/post quality plus real idempotent claim; no Skill RPC is invented. */
+export async function allocateLeaf({
+  api,
+  proposal: suppliedProposal,
+  policy,
+  config,
+  cwd,
+}) {
+  let proposal = suppliedProposal;
+  validateProposal(proposal, policy);
+  await api.main(proposal.parent);
+  const prior = await discoverPrior(api, proposal);
+  if (prior.status === "stale-outstanding")
+    return {
+      status: prior.status,
+      number: prior.issue.number,
+      workItem: `${policy.repository}#${prior.issue.number}`,
+    };
+  await api.assignable(policy.maintainer);
+  const currentEvidence = await filingEvidence(api, proposal, config, cwd);
+  const checkpoint = prior.issue
+    ? locateCheckpoint(prior.issue.comments, proposal, policy)
+    : undefined;
+  if (checkpoint) proposal = checkpoint.payload.proposal;
+  const evidence = prior.issue
+    ? historicalFiling(prior.issue)
+    : currentEvidence;
+  const roles = leafRoles(config, policy.repository);
+  const inputs = {
+    api,
+    proposal,
+    policy,
+    config,
+    prior,
+    checkpoint,
+    evidence,
+    currentEvidence,
+    roles,
+  };
+  const restored = await restoredAllocation(inputs);
+  if (restored) return restored;
+  await ensureLabels(inputs);
+  return completeAllocation(inputs);
+}