@codyswann/lisa 3.11.9 → 3.13.0

package/dist/core/guard-capabilities.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"guard-capabilities.d.ts","sourceRoot":"","sources":["../../src/core/guard-capabilities.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAsBH,oEAAoE;AACpE,MAAM,MAAM,aAAa,GAAG,WAAW,CAAC,MAAM,CAAC,CAAC;AAEhD;;;;;;;;;;;;GAYG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,MAAM,GAAG,aAAa,CAQlE;AAgBD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,aAAa,EACnB,IAAI,EAAE,aAAa,GAClB,SAAS,MAAM,EAAE,CAInB"}

package/dist/core/guard-capabilities.js

@@ -0,0 +1,102 @@
+/**
+ * The capability marker a Lisa-owned guard uses to declare what it defends
+ * against, so refresh can compare two copies by *what they stop* rather than by
+ * bytes.
+ *
+ * A byte comparison answers "are these the same?" and nothing else. It cannot
+ * answer the only question refresh actually needs answered — "is the host's copy
+ * behind mine, or ahead of it?" — and guessing "behind" is how a host's stronger
+ * guard gets silently replaced by a weaker upstream one.
+ *
+ * The marker is one comment line in the guard's header:
+ *
+ * ```
+ * # lisa-guard-capabilities: no-verify-abbrev, hookspath-allowlist, config-env
+ * ```
+ *
+ * Deliberately a *set*, not a version number. A monotonic `lisa-guard-version: N`
+ * is easier to compare but lies the moment two hosts harden different vectors
+ * independently — which is exactly what happened: `propswapllc/frontend` closed
+ * the `GIT_CONFIG_KEY_<n>` bypass while `tunnl-infrastructure` closed a different
+ * one. Both would have bumped to the same number and one would have silently
+ * won. Two sets stay two sets, and set difference names precisely what each copy
+ * has that the other does not.
+ *
+ * Only the header window is scanned. A guard whose *body* greps for the marker
+ * string, or a test fixture that quotes one, must not be read as declaring it.
+ * @module core/guard-capabilities
+ */
+/**
+ * How much of a file counts as its header.
+ *
+ * Generous enough for the long rationale comments Lisa's guards carry, small
+ * enough that the marker cannot be smuggled in from a file's body.
+ */
+const HEADER_BYTES = 4096;
+/** The token that introduces a declaration. */
+const MARKER = "lisa-guard-capabilities:";
+/**
+ * Characters allowed between the start of a line and the marker.
+ *
+ * Covers every comment syntax Lisa's owned artifacts use: `#` for shell, `//`
+ * and `*` for JS/TS. Requiring the marker to be preceded by nothing else is what
+ * makes it a declaration rather than a mention inside prose or a quoted string.
+ */
+const COMMENT_PREFIX = new Set([" ", "\t", "#", "/", "*"]);
+/**
+ * Read the capabilities a guard's header declares.
+ *
+ * Absence is not an error and not a failure signal — it means the artifact has
+ * not been enrolled, and every caller treats that as "no declaration made"
+ * rather than "declares nothing dangerous". That is what lets the marker roll
+ * out one guard at a time with no flag day.
+ * Scanned line by line with plain string operations rather than a regular
+ * expression. A header is untrusted input — it arrives from whatever repository
+ * the "host" copy came from — and a linear scan cannot be made to backtrack.
+ * @param bytes - Full contents of the guard file
+ * @returns The declared capabilities, lower-cased and de-duplicated
+ */
+export function readGuardCapabilities(bytes) {
+    const header = bytes.subarray(0, HEADER_BYTES).toString("utf8");
+    const declared = header
+        .split("\n")
+        .flatMap(line => declarationOn(line))
+        .map(entry => entry.trim().toLowerCase())
+        .filter(entry => entry.length > 0);
+    return new Set(declared);
+}
+/**
+ * The capabilities one line declares, if it is a declaration at all.
+ * @param line - A single line from the header
+ * @returns Raw comma-separated entries, or nothing when the line declares none
+ */
+function declarationOn(line) {
+    const at = line.indexOf(MARKER);
+    if (at === -1)
+        return [];
+    for (const character of line.slice(0, at)) {
+        if (!COMMENT_PREFIX.has(character))
+            return [];
+    }
+    return line.slice(at + MARKER.length).split(",");
+}
+/**
+ * The capabilities the host declares that Lisa's copy does not.
+ *
+ * A non-empty result is the whole signal: the host copy defends something
+ * upstream does not, so overwriting it removes protection. This is set
+ * *difference*, not a strict-superset test, on purpose — a host that hardened
+ * vector A while upstream hardened vector B is not a superset of upstream, yet
+ * overwriting it still deletes A. Asking only "is the host a superset?" would
+ * clobber precisely the divergent-hardening case the set representation exists
+ * to handle.
+ * @param host - Capabilities declared by the installed copy
+ * @param lisa - Capabilities declared by the packaged copy
+ * @returns Capabilities present on the host and absent upstream, sorted
+ */
+export function capabilitiesOnlyOnHost(host, lisa) {
+    return [...host]
+        .filter(capability => !lisa.has(capability))
+        .sort((left, right) => left.localeCompare(right));
+}
+//# sourceMappingURL=guard-capabilities.js.map

package/dist/core/guard-capabilities.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"guard-capabilities.js","sourceRoot":"","sources":["../../src/core/guard-capabilities.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH;;;;;GAKG;AACH,MAAM,YAAY,GAAG,IAAI,CAAC;AAE1B,+CAA+C;AAC/C,MAAM,MAAM,GAAG,0BAA0B,CAAC;AAE1C;;;;;;GAMG;AACH,MAAM,cAAc,GAAG,IAAI,GAAG,CAAC,CAAC,GAAG,EAAE,IAAI,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC,CAAC;AAK3D;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,qBAAqB,CAAC,KAAa;IACjD,MAAM,MAAM,GAAG,KAAK,CAAC,QAAQ,CAAC,CAAC,EAAE,YAAY,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;IAChE,MAAM,QAAQ,GAAG,MAAM;SACpB,KAAK,CAAC,IAAI,CAAC;SACX,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC;SACpC,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC;SACxC,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;IACrC,OAAO,IAAI,GAAG,CAAC,QAAQ,CAAC,CAAC;AAC3B,CAAC;AAED;;;;GAIG;AACH,SAAS,aAAa,CAAC,IAAY;IACjC,MAAM,EAAE,GAAG,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;IAChC,IAAI,EAAE,KAAK,CAAC,CAAC;QAAE,OAAO,EAAE,CAAC;IACzB,KAAK,MAAM,SAAS,IAAI,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,EAAE,CAAC;QAC1C,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,SAAS,CAAC;YAAE,OAAO,EAAE,CAAC;IAChD,CAAC;IACD,OAAO,IAAI,CAAC,KAAK,CAAC,EAAE,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;AACnD,CAAC;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,sBAAsB,CACpC,IAAmB,EACnB,IAAmB;IAEnB,OAAO,CAAC,GAAG,IAAI,CAAC;SACb,MAAM,CAAC,UAAU,CAAC,EAAE,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;SAC3C,IAAI,CAAC,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,CAAC,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC,CAAC;AACtD,CAAC"}

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

@@ -0,0 +1,11 @@
+/** Generated by scripts/generate-lisa-owned-hash-ledger.mjs. Do not edit. */
+/**
+ * Every content hash Lisa has published at each Lisa-owned destination path.
+ *
+ * A host copy whose hash appears here is provably an older Lisa artifact and may
+ * be refreshed. One that appears nowhere here was edited downstream, and refresh
+ * refuses rather than risk deleting a stronger guard. See
+ * `src/core/lisa-owned-provenance.ts`.
+ */
+export declare const LISA_OWNED_HASH_LEDGER: Readonly<Record<string, readonly string[]>>;
+//# sourceMappingURL=lisa-owned-hash-ledger.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"lisa-owned-hash-ledger.d.ts","sourceRoot":"","sources":["../../src/core/lisa-owned-hash-ledger.ts"],"names":[],"mappings":"AAAA,6EAA6E;AAE7E;;;;;;;GAOG;AACH,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAC3C,MAAM,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC,CAqHjC,CAAC"}

package/dist/core/lisa-owned-hash-ledger.js

@@ -0,0 +1,127 @@
+/** Generated by scripts/generate-lisa-owned-hash-ledger.mjs. Do not edit. */
+/**
+ * Every content hash Lisa has published at each Lisa-owned destination path.
+ *
+ * A host copy whose hash appears here is provably an older Lisa artifact and may
+ * be refreshed. One that appears nowhere here was edited downstream, and refresh
+ * refuses rather than risk deleting a stronger guard. See
+ * `src/core/lisa-owned-provenance.ts`.
+ */
+export const LISA_OWNED_HASH_LEDGER = Object.freeze({
+    "scripts/lisa-clean-git-env.sh": Object.freeze([
+        "d15af6f13eedbca41046070972380e69fc0af8f7d903aac12b8644389b9a0c91",
+        "e7121a0ee9e1bf7c01cd2ab55f563dd6d9ab75990739bb6ddf571a513efa10e9",
+    ]),
+    "scripts/lisa-command-envelope.mjs": Object.freeze([
+        "2011331056b1c86bd181649713a395dbfd2768f9fcd7e37b521d6ad2a9318ea9",
+        "4f76bb7d466eb153a4e1414d06f12856a1242de2cfa4cb4b1b942cf29d8b7f37",
+        "6b198f088cd3cd862d4357fbb069b1ad5d3afeb7be594f2bf1ff603b092a8354",
+        "e06cb11f1418fe94564cea527a22b039f53b7ab10c1cd182264a31e52bba9fa8",
+    ]),
+    "scripts/lisa-destructive-guard.mjs": Object.freeze([
+        "4fb431a3c58f443e303d613934d023d9e95ddae5c42710bb7009f7c080c82a64",
+    ]),
+    "scripts/lisa-enforcement-fallback.sh": Object.freeze([
+        "1bec5f3c284b3febdc471487ee6a23ffb72bd4e7b293f9e26b0188f32318c722",
+        "3049c2f1051c7c02dd60b62355964651e1565ebe6bdcb5e37634cd686cf1deb1",
+        "8dc942ac4edc2017d6b8277296c8f80542e7c024eef1bb65de609979d0ca9a0e",
+        "9cab71562d01421d57c6719318a4d03a6249a45c1aea434db3ff26e3065eeb66",
+        "d7d88e44763694bed5eae998cd3663922c957e49f9f9621d9201f0417a4128ad",
+        "e17c45f7cadf0fb55dd07270776caf211af99b7d4771a4fde75aafe5919e8dbe",
+    ]),
+    "scripts/lisa-floor-collisions.mjs": Object.freeze([
+        "2d11968f6852ab745cba939de03c6d6cb5f413975d2cfc8fc447bdd0b218e91a",
+        "3c7a0234b4f5609fce49e44711d2ec86af8cf7fb82b0831e4450e3347ecefe45",
+        "a612f172282d13ba9318fe5e03689d7c6ff42a0122d0c9d5d39051e1967b93dc",
+    ]),
+    "scripts/lisa-hooks/block-direct-issue-create.sh": Object.freeze([
+        "22184f1dd1b96e818741bd4ae659446299535d7ce594817155edebac4172a7ba",
+        "60a4f94ec671b2372f7492680ab327d97aff686588ce85791f54e0fbd098b0ca",
+        "73e94b73830d8961026947d99bf4ac5f959b5bca025203b913d8a6363cbe2b9f",
+        "847dfca48823a495fc3de47dfdb4b26e49d6808c6570c46d024a99793df1d370",
+    ]),
+    "scripts/lisa-hooks/block-instruction-file-edits.sh": Object.freeze([
+        "6f52076e3488821d638b6dd45b5faca527d92b181cc12e6e5033859e0786c8a7",
+        "850cfc23852eb752114ae1e938a1c7bcf34bc50c85d3aaca0c02311cc8c0ef70",
+        "8996e0bcbf1db085a5d99734e797c91f5025997bd967bc374efff8348dac14c2",
+        "be1e77fb0ddb246eddae71ebac25e972c3c9e8079514e0dc78d0b73df919464c",
+        "d47314b66d6ce85f77d6e058f861eede4462b2b0a33d54e82ff1c931167ec3f7",
+    ]),
+    "scripts/lisa-hooks/block-no-verify.sh": Object.freeze([
+        "031ef7a53fc49cb18665105b834b7b50ad6a43317e0821949809e877e0562ce4",
+        "18b7bb8867c5e6f719a9c503a38525f4c05e3d611717c3e1a503cf58dfb2832f",
+        "2df476aacebcb2544a12f459a0092e88eb28c0d00e45fd7ed909c75dfe441027",
+        "33e2bd341eb992036059b0c4606db35a218adcfeca7e44d174fedf8ebdff29d2",
+        "3b93a0affab6413e3c14a6f43de5acb586286ed1819ece0a66b30429b4d00490",
+        "3ff7255f395a9552366faaac34d383f4c95fecfb39882cd1d57854356422fe61",
+        "7790a560850c9d38709dbaccdaa10733e632c1bd4d975cbec7e3cc5a8650b36a",
+        "a6ed91576efebb6ba40cfa4e9d8a3e8566314909210ae8d5860be62a3feb4cff",
+        "aa95a84f9f9224914947a09b858535aa8bd052199ff64cb53768cf78fb69b687",
+        "b9f299cb9d3ad75b71296376ae2c40eb207a3b2706dafdaa41fc586050a53aad",
+        "dd1aea1b9fdd0da023bf704b331b350bc14620f4364afa5001c6690fcbc940cc",
+        "e3407d63eae16662923d46b75b6a41e7ca7ab206b428ea2cbb0b4fee226f6516",
+    ]),
+    "scripts/lisa-hooks/block-shell-json-parsing.sh": Object.freeze([
+        "1934a15e154fda3c2a40979a5cd6225661b14fe7bc77328a69ce499bea85dba7",
+        "3b5f074f3ab5708030af507eea962389f3b067c5dbdc76580bd9e44d3ac6c603",
+        "90601e31603c440d8f19d213d63bfef8d18596c60f88cb6e28c93d12453c5c0c",
+    ]),
+    "scripts/lisa-hooks/parity-safety-net.sh": Object.freeze([
+        "062c69eea85157f1e941ec3626d8912aa9f182af6ccdbe19687588a6074db5ce",
+        "07002535de10d89f6d73e8922517550a02a8974549aaf200c9c314e6f4f83c70",
+        "1162ffd16cef3b23282d2f5207abcb88429462a74a9df1035f0df4968f6dd456",
+        "14fc5e292aebf83dd24fec12fb32e2beb509a9324f127a24a64d5c5d4d05c576",
+        "1bf3512bb94923a6cb25b1e7a619a3fc8e1336bffa16f499b459aaee3eaed66d",
+        "388cf8847581d96a1ff8ea98290a33a5f96d67cdd502ea807a0b8d88efe90e19",
+        "64546813f168fb446f39e34bc674fd3af85b15bd5e7f4f6bf4503463e701a7b9",
+        "772202ddd42d626625ff719666afbbe83445d8bae1bc7c0fb5ffdcb402be83f8",
+        "7f55986eb29f8ace8616595da4bbe60d80a96f9f29b24fb72efd66bb96b22464",
+        "8e19d5f1ba7abe3d22fbee47ff8e0fad76b965ccca20b8849e3c43ab07d9a4ef",
+        "a22fd1b7c483f1a538202353ee85c82be17a8910e03c0a930635ce8cb3595c64",
+        "b83c5043a0f29b2d8851258acfe6906aab7922cd80f486e25220e55f26a8c0a5",
+        "caea02a07027fc1c74d47e08b36299d369c5c9f7c4043da8828fbca3c64eb2aa",
+        "d12583803e8ff5e4b64e68eafc8d3c377af4c400d8b7ecd1c7fe699d8f92784a",
+        "d9ea58150aa27e7f0aa9a4ef155ed446d30bdfc932d01c64e2b8ca211aa0de7b",
+        "f740f600b255742a50f28e5c9d09427c5783c4084e84052dca46bc1f0c94a187",
+        "fa8f4a6517eacd9266feb7afd62398cdf2075d4824cac24b45bb64ad0cd18c86",
+    ]),
+    "scripts/lisa-hooks/sonar-secrets.sh": Object.freeze([
+        "7a408788975a6351d53e14aa32bb9a5d161f33df9dfea59ba32784ae33a62e67",
+        "945453fb275a58aa7185e150e6b05e5810739750928ab5bd6edfbf87d1c8aa0d",
+        "bf4132e49ba18e2f7e941520c299c15aeeacfd220e489f3d2eb8397f2048157b",
+    ]),
+    "scripts/lisa-mutation.mjs": Object.freeze([
+        "7d8d24dea151ef2178807046e97aea7ebfadd9c88eb50347feb7bb4bb190227d",
+        "8e0bdb491dfaea04e88be1c1e2c6cc7cd34fa4ca18adddf5fecc43d7de8ffded",
+        "a630bde6cddae283776b8d34763a3642edbea8096d583a90ec6d43a9588ca8a6",
+    ]),
+    "scripts/lisa-schema-validate.mjs": Object.freeze([
+        "2ace82daacdebbbb00a7eceb09fbe82cabec04330a083ca10417b2ee4e0a63eb",
+        "4a05a0ed70a274827fd2f0fd0c98890c66bee2fde70785b8379943ebe6650473",
+        "9dd145c0f9dac6ed252b13d32e130dbab964da6cd357981b58541780ecb2f981",
+    ]),
+    "scripts/lisa-work-item.mjs": Object.freeze([
+        "238dc2da29938edd92518c2b08192d14c6f2751ed175c07d6e882814829b7b7e",
+        "2d9ca0841db9e75ddfd95e3a4d485fd01aa639a512ef648996f565b7991d8e2b",
+        "4c263fef48c03b3b6c623ea8a6cd55505bfaf28197e5072226ea35f9f3d26885",
+        "5eb31c284e820a51312d4484f0669128007326af55ee515923fec33700d003a1",
+        "6a8be8577242588f14ab52b25b2a22b6def53aefa9513b4d3d7c49f4d8027079",
+        "9223856be4618fb1e3e731b259ae5bf5328decc322f0b4a0d0fd18d6b12cd45a",
+        "96a87c131606b3edd43e52485e68f8ffbf5c528cb4beb7a1185263519a9632ce",
+        "ab0dede91c5c8a07984ae13aa48ec70cdcd2fa691b59617bc4b57998dc79a51c",
+        "c78df9d5f0f3fc388ff60a7db5898478a2a4d6d7325833f10384b5a8c62bb34a",
+        "e30016a49deff1c3cd3ae7951262aeb2ef3d472bce76bbbe2a177db6017c7cad",
+        "e41e9534988ce69a836664437a78f3a3f3dc7ebbe396c86cdab0ea63fb7c19da",
+        "f12006df4ed9974f65d955718af7dcc8a079799d02c58bd38b2d9c49f271db72",
+        "f88f69d44693084428f44e3f2b80afecda08c7ee8747588f40277fdc9396fd8f",
+        "fc0d92739e620d8fd70f7aa4a12d3e0b3a8f790d47c4a8322040f32c30b9445a",
+        "fe064a2bd11200ed256fb36e203978f858fccbcaf40708496c066383345900ef",
+    ]),
+    "scripts/schemas/lisa-command-envelope.v1.schema.json": Object.freeze([
+        "d153b7c2953a30f180e38f09e98240c63327f5196eeba9bdf545e5a1f125a879",
+    ]),
+    "scripts/schemas/lisa-state-contract.v1.schema.json": Object.freeze([
+        "6b7afe4ffeba8aaa53871d8855172f7eacde05953b1321145218ec638ff5c1c4",
+    ]),
+});
+//# sourceMappingURL=lisa-owned-hash-ledger.js.map

package/dist/core/lisa-owned-hash-ledger.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lisa-owned-hash-ledger.js","sourceRoot":"","sources":["../../src/core/lisa-owned-hash-ledger.ts"],"names":[],"mappings":"AAAA,6EAA6E;AAE7E;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,sBAAsB,GAE/B,MAAM,CAAC,MAAM,CAAC;IAChB,+BAA+B,EAAE,MAAM,CAAC,MAAM,CAAC;QAC7C,kEAAkE;QAClE,kEAAkE;KACnE,CAAC;IACF,mCAAmC,EAAE,MAAM,CAAC,MAAM,CAAC;QACjD,kEAAkE;QAClE,kEAAkE;QAClE,kEAAkE;QAClE,kEAAkE;KACnE,CAAC;IACF,oCAAoC,EAAE,MAAM,CAAC,MAAM,CAAC;QAClD,kEAAkE;KACnE,CAAC;IACF,sCAAsC,EAAE,MAAM,CAAC,MAAM,CAAC;QACpD,kEAAkE;QAClE,kEAAkE;QAClE,kEAAkE;QAClE,kEAAkE;QAClE,kEAAkE;QAClE,kEAAkE;KACnE,CAAC;IACF,mCAAmC,EAAE,MAAM,CAAC,MAAM,CAAC;QACjD,kEAAkE;QAClE,kEAAkE;QAClE,kEAAkE;KACnE,CAAC;IACF,iDAAiD,EAAE,MAAM,CAAC,MAAM,CAAC;QAC/D,kEAAkE;QAClE,kEAAkE;QAClE,kEAAkE;QAClE,kEAAkE;KACnE,CAAC;IACF,oDAAoD,EAAE,MAAM,CAAC,MAAM,CAAC;QAClE,kEAAkE;QAClE,kEAAkE;QAClE,kEAAkE;QAClE,kEAAkE;QAClE,kEAAkE;KACnE,CAAC;IACF,uCAAuC,EAAE,MAAM,CAAC,MAAM,CAAC;QACrD,kEAAkE;QAClE,kEAAkE;QAClE,kEAAkE;QAClE,kEAAkE;QAClE,kEAAkE;QAClE,kEAAkE;QAClE,kEAAkE;QAClE,kEAAkE;QAClE,kEAAkE;QAClE,kEAAkE;QAClE,kEAAkE;QAClE,kEAAkE;KACnE,CAAC;IACF,gDAAgD,EAAE,MAAM,CAAC,MAAM,CAAC;QAC9D,kEAAkE;QAClE,kEAAkE;QAClE,kEAAkE;KACnE,CAAC;IACF,yCAAyC,EAAE,MAAM,CAAC,MAAM,CAAC;QACvD,kEAAkE;QAClE,kEAAkE;QAClE,kEAAkE;QAClE,kEAAkE;QAClE,kEAAkE;QAClE,kEAAkE;QAClE,kEAAkE;QAClE,kEAAkE;QAClE,kEAAkE;QAClE,kEAAkE;QAClE,kEAAkE;QAClE,kEAAkE;QAClE,kEAAkE;QAClE,kEAAkE;QAClE,kEAAkE;QAClE,kEAAkE;QAClE,kEAAkE;KACnE,CAAC;IACF,qCAAqC,EAAE,MAAM,CAAC,MAAM,CAAC;QACnD,kEAAkE;QAClE,kEAAkE;QAClE,kEAAkE;KACnE,CAAC;IACF,2BAA2B,EAAE,MAAM,CAAC,MAAM,CAAC;QACzC,kEAAkE;QAClE,kEAAkE;QAClE,kEAAkE;KACnE,CAAC;IACF,kCAAkC,EAAE,MAAM,CAAC,MAAM,CAAC;QAChD,kEAAkE;QAClE,kEAAkE;QAClE,kEAAkE;KACnE,CAAC;IACF,4BAA4B,EAAE,MAAM,CAAC,MAAM,CAAC;QAC1C,kEAAkE;QAClE,kEAAkE;QAClE,kEAAkE;QAClE,kEAAkE;QAClE,kEAAkE;QAClE,kEAAkE;QAClE,kEAAkE;QAClE,kEAAkE;QAClE,kEAAkE;QAClE,kEAAkE;QAClE,kEAAkE;QAClE,kEAAkE;QAClE,kEAAkE;QAClE,kEAAkE;QAClE,kEAAkE;KACnE,CAAC;IACF,sDAAsD,EAAE,MAAM,CAAC,MAAM,CAAC;QACpE,kEAAkE;KACnE,CAAC;IACF,oDAAoD,EAAE,MAAM,CAAC,MAAM,CAAC;QAClE,kEAAkE;KACnE,CAAC;CACH,CAAC,CAAC"}

package/dist/core/lisa-owned-provenance.d.ts

@@ -0,0 +1,75 @@
+/** Known-good hashes per Lisa-owned destination path. */
+export type HashLedger = Readonly<Record<string, readonly string[]>>;
+/** What refresh concluded about a host's copy of a Lisa-owned artifact. */
+export type ProvenanceVerdict = 
+/** Byte-identical to Lisa's copy; there is nothing to decide. */
+{
+    readonly kind: "identical";
+}
+/** Declares hardening Lisa lacks. Preserve, and name what would be lost. */
+ | {
+    readonly kind: "host-ahead";
+    readonly extraCapabilities: readonly string[];
+}
+/** Content Lisa never shipped, with nothing declared. Preserve and report. */
+ | {
+    readonly kind: "host-modified";
+}
+/** Declared hardening that upstream now also has. Safe to refresh. */
+ | {
+    readonly kind: "absorbed-upstream";
+}
+/** Hash matches a Lisa release. Genuinely stale, so refresh it. */
+ | {
+    readonly kind: "provably-stale";
+}
+/** Artifact carries no provenance yet; behave exactly as before this change. */
+ | {
+    readonly kind: "unenrolled";
+};
+/**
+ * The verdicts under which the host's copy is kept.
+ *
+ * Derived from `ProvenanceVerdict` rather than restated, so a verdict added
+ * later cannot quietly go unhandled: `mayRefreshLisaOwned` must classify it, and
+ * anything it declines to refresh has to be describable here.
+ */
+export type PreservedVerdict = Extract<ProvenanceVerdict, {
+    readonly kind: "host-ahead" | "host-modified";
+}>;
+/**
+ * Decide whether a host's copy of a Lisa-owned artifact may be overwritten.
+ *
+ * Order matters. Capabilities are consulted before the ledger because a
+ * declaration is an explicit statement of intent by whoever edited the file, and
+ * an explicit statement outranks an inference drawn from a hash table.
+ * @param relativePath - Repo-relative destination path of the artifact
+ * @param hostBytes - Contents currently installed in the host project
+ * @param lisaBytes - Contents Lisa ships for that path
+ * @param ledger - Known-good hash ledger (injected by tests)
+ * @returns The verdict describing which side is ahead
+ */
+export declare function classifyHostCopy(relativePath: string, hostBytes: Buffer, lisaBytes: Buffer, ledger?: HashLedger): ProvenanceVerdict;
+/**
+ * Whether refresh is allowed to replace the host's copy.
+ *
+ * The default is deliberately asymmetric. Failing closed leaves a stale file in
+ * place and tells somebody about it; failing open deletes a security control and
+ * tells nobody. Those costs are not comparable, so anything short of proof that
+ * the host is behind means the host's copy stays.
+ * @param verdict - Result of `classifyHostCopy`
+ * @returns True when the host copy is provably not ahead
+ */
+export declare function mayRefreshLisaOwned(verdict: ProvenanceVerdict): verdict is Exclude<ProvenanceVerdict, PreservedVerdict>;
+/**
+ * Explain a preserved file to whoever is reading the apply output.
+ *
+ * Written for an operator who did not make the change and may not be an
+ * engineer: it names the file, says plainly that theirs is the stronger copy,
+ * and gives the two actions that end the standoff.
+ * @param relativePath - Repo-relative destination path of the artifact
+ * @param verdict - Result of `classifyHostCopy`
+ * @returns One operator-readable sentence, or undefined when nothing was held back
+ */
+export declare function describePreserved(relativePath: string, verdict: PreservedVerdict): string;
+//# sourceMappingURL=lisa-owned-provenance.d.ts.map

package/dist/core/lisa-owned-provenance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lisa-owned-provenance.d.ts","sourceRoot":"","sources":["../../src/core/lisa-owned-provenance.ts"],"names":[],"mappings":"AAsDA,yDAAyD;AACzD,MAAM,MAAM,UAAU,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC,CAAC,CAAC;AAQrE,2EAA2E;AAC3E,MAAM,MAAM,iBAAiB;AAC3B,iEAAiE;AAC/D;IAAE,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAA;CAAE;AAChC,4EAA4E;GAC1E;IACE,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAC;IAC5B,QAAQ,CAAC,iBAAiB,EAAE,SAAS,MAAM,EAAE,CAAC;CAC/C;AACH,8EAA8E;GAC5E;IAAE,QAAQ,CAAC,IAAI,EAAE,eAAe,CAAA;CAAE;AACpC,sEAAsE;GACpE;IAAE,QAAQ,CAAC,IAAI,EAAE,mBAAmB,CAAA;CAAE;AACxC,mEAAmE;GACjE;IAAE,QAAQ,CAAC,IAAI,EAAE,gBAAgB,CAAA;CAAE;AACrC,gFAAgF;GAC9E;IAAE,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAA;CAAE,CAAC;AAEpC;;;;;;GAMG;AACH,MAAM,MAAM,gBAAgB,GAAG,OAAO,CACpC,iBAAiB,EACjB;IAAE,QAAQ,CAAC,IAAI,EAAE,YAAY,GAAG,eAAe,CAAA;CAAE,CAClD,CAAC;AAWF;;;;;;;;;;;GAWG;AACH,wBAAgB,gBAAgB,CAC9B,YAAY,EAAE,MAAM,EACpB,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,EACjB,MAAM,GAAE,UAAmC,GAC1C,iBAAiB,CAkBnB;AAWD;;;;;;;;;GASG;AACH,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,iBAAiB,GACzB,OAAO,IAAI,OAAO,CAAC,iBAAiB,EAAE,gBAAgB,CAAC,CAEzD;AAED;;;;;;;;;GASG;AACH,wBAAgB,iBAAiB,CAC/B,YAAY,EAAE,MAAM,EACpB,OAAO,EAAE,gBAAgB,GACxB,MAAM,CAIR"}

package/dist/core/lisa-owned-provenance.js

@@ -0,0 +1,127 @@
+/**
+ * Whether a host's copy of a Lisa-owned artifact is *behind* Lisa's or *ahead*
+ * of it — the question byte comparison cannot answer.
+ *
+ * Refresh (#2436) decided whether to overwrite a host's copy by comparing bytes.
+ * Unequal bytes were read as "the host is out of date", which is one of two
+ * possibilities and not the dangerous one. When the host copy is ahead —
+ * a guard hardened downstream before upstream caught up — the same comparison
+ * produces the same answer, and the overwrite silently deletes a security
+ * control. `propswapllc/frontend` closed the `GIT_CONFIG_KEY_<n>` hooks-path
+ * bypass before Lisa did; a `bun install` regenerated the file and reverted the
+ * hardening with no warning and no failure. Their own tests caught it. Nothing
+ * in Lisa would have.
+ *
+ * ## How "behind" gets proved
+ *
+ * The primary signal is provenance by content hash. Lisa ships a ledger of every
+ * sha256 it has ever published at each Lisa-owned destination path (see
+ * `scripts/generate-lisa-owned-hash-ledger.mjs`). A host's copy came from some
+ * past Lisa, so if its hash is in the ledger it is *provably* an older Lisa
+ * artifact and refreshing it is correct. If the hash appears nowhere in Lisa's
+ * shipping history, somebody downstream edited it, and refresh has no basis to
+ * call that stale.
+ *
+ * Hashes are the primary signal rather than capability markers because markers
+ * only protect a host that *declared*. propswap did not declare; they edited the
+ * guard. A marker-only design would still have clobbered the very incident that
+ * motivated this. The ledger protects undeclared hardening, retroactively, with
+ * no host-side action required.
+ *
+ * A ledger beats a receipt file written at apply time for the same reason: a
+ * receipt has to be written by a *prior* apply to arm the mechanism, so the first
+ * apply after the change is the one that clobbers — it fails exactly once, on the
+ * case that matters most.
+ *
+ * ## How the standoff ends
+ *
+ * Refusing forever is its own failure: genuine drift would accumulate and never
+ * be fixed. Capability markers are the release valve. When the host declares
+ * capabilities and Lisa's copy declares all of them, upstream has absorbed the
+ * host's hardening, so overwriting restores parity instead of removing
+ * protection — and refresh resumes automatically, with no operator action. A
+ * host that hardened without declaring gets told to do one of the two things
+ * that end the standoff: land it upstream, or declare it.
+ * @module core/lisa-owned-provenance
+ */
+import { createHash } from "node:crypto";
+import { capabilitiesOnlyOnHost, readGuardCapabilities, } from "./guard-capabilities.js";
+import { LISA_OWNED_HASH_LEDGER } from "./lisa-owned-hash-ledger.js";
+/** The verdict for content Lisa has no record of ever having shipped. */
+const HOST_MODIFIED = "host-modified";
+/** The verdict for a copy declaring hardening Lisa's copy does not. */
+const HOST_AHEAD = "host-ahead";
+/**
+ * Hex sha256 of a file's contents.
+ * @param bytes - File contents
+ * @returns Lower-case hex digest
+ */
+function digest(bytes) {
+    return createHash("sha256").update(bytes).digest("hex");
+}
+/**
+ * Decide whether a host's copy of a Lisa-owned artifact may be overwritten.
+ *
+ * Order matters. Capabilities are consulted before the ledger because a
+ * declaration is an explicit statement of intent by whoever edited the file, and
+ * an explicit statement outranks an inference drawn from a hash table.
+ * @param relativePath - Repo-relative destination path of the artifact
+ * @param hostBytes - Contents currently installed in the host project
+ * @param lisaBytes - Contents Lisa ships for that path
+ * @param ledger - Known-good hash ledger (injected by tests)
+ * @returns The verdict describing which side is ahead
+ */
+export function classifyHostCopy(relativePath, hostBytes, lisaBytes, ledger = LISA_OWNED_HASH_LEDGER) {
+    if (hostBytes.equals(lisaBytes))
+        return { kind: "identical" };
+    const hostCapabilities = readGuardCapabilities(hostBytes);
+    const extraCapabilities = capabilitiesOnlyOnHost(hostCapabilities, readGuardCapabilities(lisaBytes));
+    if (extraCapabilities.length > 0) {
+        return { kind: HOST_AHEAD, extraCapabilities };
+    }
+    if (hostCapabilities.size > 0)
+        return { kind: "absorbed-upstream" };
+    const known = ledger[normalise(relativePath)];
+    if (known === undefined || known.length === 0)
+        return { kind: "unenrolled" };
+    return known.includes(digest(hostBytes))
+        ? { kind: "provably-stale" }
+        : { kind: HOST_MODIFIED };
+}
+/**
+ * Normalise a destination path to the ledger's key form.
+ * @param relativePath - Repo-relative destination path
+ * @returns The path with forward slashes
+ */
+function normalise(relativePath) {
+    return relativePath.replaceAll("\\", "/");
+}
+/**
+ * Whether refresh is allowed to replace the host's copy.
+ *
+ * The default is deliberately asymmetric. Failing closed leaves a stale file in
+ * place and tells somebody about it; failing open deletes a security control and
+ * tells nobody. Those costs are not comparable, so anything short of proof that
+ * the host is behind means the host's copy stays.
+ * @param verdict - Result of `classifyHostCopy`
+ * @returns True when the host copy is provably not ahead
+ */
+export function mayRefreshLisaOwned(verdict) {
+    return verdict.kind !== HOST_AHEAD && verdict.kind !== HOST_MODIFIED;
+}
+/**
+ * Explain a preserved file to whoever is reading the apply output.
+ *
+ * Written for an operator who did not make the change and may not be an
+ * engineer: it names the file, says plainly that theirs is the stronger copy,
+ * and gives the two actions that end the standoff.
+ * @param relativePath - Repo-relative destination path of the artifact
+ * @param verdict - Result of `classifyHostCopy`
+ * @returns One operator-readable sentence, or undefined when nothing was held back
+ */
+export function describePreserved(relativePath, verdict) {
+    return verdict.kind === HOST_AHEAD
+        ? `${relativePath}: your copy guards against ${verdict.extraCapabilities.join(", ")}, which Lisa's copy does not. Kept yours. To take Lisa's copy later, contribute your hardening upstream — refresh resumes on its own once Lisa declares it too.`
+        : `${relativePath}: this file was edited in your project — its contents match no Lisa release, so Lisa cannot tell whether it is out of date or deliberately stronger. Kept yours. Review the difference, then either contribute the change upstream or add a \`lisa-guard-capabilities:\` line naming what it defends.`;
+}
+//# sourceMappingURL=lisa-owned-provenance.js.map

package/dist/core/lisa-owned-provenance.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lisa-owned-provenance.js","sourceRoot":"","sources":["../../src/core/lisa-owned-provenance.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAEzC,OAAO,EACL,sBAAsB,EACtB,qBAAqB,GACtB,MAAM,yBAAyB,CAAC;AACjC,OAAO,EAAE,sBAAsB,EAAE,MAAM,6BAA6B,CAAC;AAKrE,yEAAyE;AACzE,MAAM,aAAa,GAAG,eAAwB,CAAC;AAE/C,uEAAuE;AACvE,MAAM,UAAU,GAAG,YAAqB,CAAC;AAgCzC;;;;GAIG;AACH,SAAS,MAAM,CAAC,KAAa;IAC3B,OAAO,UAAU,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;AAC1D,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,gBAAgB,CAC9B,YAAoB,EACpB,SAAiB,EACjB,SAAiB,EACjB,SAAqB,sBAAsB;IAE3C,IAAI,SAAS,CAAC,MAAM,CAAC,SAAS,CAAC;QAAE,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,CAAC;IAE9D,MAAM,gBAAgB,GAAG,qBAAqB,CAAC,SAAS,CAAC,CAAC;IAC1D,MAAM,iBAAiB,GAAG,sBAAsB,CAC9C,gBAAgB,EAChB,qBAAqB,CAAC,SAAS,CAAC,CACjC,CAAC;IACF,IAAI,iBAAiB,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QACjC,OAAO,EAAE,IAAI,EAAE,UAAU,EAAE,iBAAiB,EAAE,CAAC;IACjD,CAAC;IACD,IAAI,gBAAgB,CAAC,IAAI,GAAG,CAAC;QAAE,OAAO,EAAE,IAAI,EAAE,mBAAmB,EAAE,CAAC;IAEpE,MAAM,KAAK,GAAG,MAAM,CAAC,SAAS,CAAC,YAAY,CAAC,CAAC,CAAC;IAC9C,IAAI,KAAK,KAAK,SAAS,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,EAAE,IAAI,EAAE,YAAY,EAAE,CAAC;IAC7E,OAAO,KAAK,CAAC,QAAQ,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC;QACtC,CAAC,CAAC,EAAE,IAAI,EAAE,gBAAgB,EAAE;QAC5B,CAAC,CAAC,EAAE,IAAI,EAAE,aAAa,EAAE,CAAC;AAC9B,CAAC;AAED;;;;GAIG;AACH,SAAS,SAAS,CAAC,YAAoB;IACrC,OAAO,YAAY,CAAC,UAAU,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC;AAC5C,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,mBAAmB,CACjC,OAA0B;IAE1B,OAAO,OAAO,CAAC,IAAI,KAAK,UAAU,IAAI,OAAO,CAAC,IAAI,KAAK,aAAa,CAAC;AACvE,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,iBAAiB,CAC/B,YAAoB,EACpB,OAAyB;IAEzB,OAAO,OAAO,CAAC,IAAI,KAAK,UAAU;QAChC,CAAC,CAAC,GAAG,YAAY,8BAA8B,OAAO,CAAC,iBAAiB,CAAC,IAAI,CAAC,IAAI,CAAC,iKAAiK;QACpP,CAAC,CAAC,GAAG,YAAY,uSAAuS,CAAC;AAC7T,CAAC"}

package/dist/core/lisa.d.ts

@@ -33,6 +33,15 @@ export declare class Lisa {
      * back to the silence this exists to end.
      */
     private readonly stalePaths;
+    /**
+     * Lisa-owned artifacts this apply deliberately did not replace, each with the
+     * reason spelled out for whoever reads the output.
+     *
+     * Full sentences rather than paths, because this is the one outcome an
+     * operator cannot act on from the filename: "we left yours alone because it
+     * defends something ours does not" is the entire message.
+     */
+    private readonly hostAheadNotes;
     private detectedTypes;
     private ignorePatterns;
     /**
@@ -663,6 +672,15 @@ export declare class Lisa {
      * that stayed on its old version while the release notes said otherwise.
      */
     private printStaleDetail;
+    /**
+     * Report Lisa-owned artifacts this apply chose not to replace.
+     *
+     * Reported as good news, not as a warning about the project: keeping a guard
+     * that is stronger than Lisa's is the correct outcome, and phrasing it as a
+     * problem would push an operator to "fix" it by discarding their own
+     * hardening — the exact loss the check exists to prevent.
+     */
+    private printHostAheadDetail;
     /**
      * Print summary statistics
      */

package/dist/core/lisa.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lisa.d.ts","sourceRoot":"","sources":["../../src/core/lisa.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"lisa.d.ts","sourceRoot":"","sources":["../../src/core/lisa.ts"],"names":[],"mappings":"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"}

package/dist/core/lisa.js

@@ -53,6 +53,15 @@ export class Lisa {
      * back to the silence this exists to end.
      */
     stalePaths = [];
+    /**
+     * Lisa-owned artifacts this apply deliberately did not replace, each with the
+     * reason spelled out for whoever reads the output.
+     *
+     * Full sentences rather than paths, because this is the one outcome an
+     * operator cannot act on from the filename: "we left yours alone because it
+     * defends something ours does not" is the entire message.
+     */
+    hostAheadNotes = [];
     detectedTypes = [];
     ignorePatterns = {
         patterns: [],
@@ -1489,6 +1498,10 @@ export class Lisa {
                 this.counters.stale++;
                 this.stalePaths.push(result.relativePath);
                 break;
+            case "host-ahead":
+                this.counters.hostAhead++;
+                this.hostAheadNotes.push(result.note ?? `${result.relativePath}: kept your copy.`);
+                break;
             case "overwritten":
                 this.counters.overwritten++;
                 break;
@@ -1529,6 +1542,11 @@ export class Lisa {
                     ? `Out of date, would not be updated: ${result.relativePath}`
                     : `Out of date, not updated: ${result.relativePath}`);
                 break;
+            case "host-ahead":
+                this.deps.logger.warn(this.config.dryRun
+                    ? `Would keep your copy: ${result.relativePath}`
+                    : `Kept your copy: ${result.relativePath}`);
+                break;
             case "overwritten":
                 this.logMessage(`Would prompt to overwrite: ${result.relativePath}`, `Overwritten: ${result.relativePath}`);
                 break;
@@ -1669,6 +1687,7 @@ export class Lisa {
             this.printStatLine("Would ignore:   ", ignored, pc.magenta, this.lisaignoreSuffix);
         }
         this.printStaleDetail();
+        this.printHostAheadDetail();
     }
     /**
      * Print summary statistics for apply mode
@@ -1690,6 +1709,7 @@ export class Lisa {
             this.printStatLine("Ignored:    ", ignored, pc.magenta, this.lisaignoreSuffix);
         }
         this.printStaleDetail();
+        this.printHostAheadDetail();
     }
     /**
      * Name the out-of-date managed files and say how to update them.
@@ -1712,6 +1732,24 @@ export class Lisa {
         logger.info("A non-interactive apply will not replace a file your project may have customised.");
         logger.info("Review the differences and run `lisa apply .` interactively to take them, or add paths to .lisaignore to keep yours.");
     }
+    /**
+     * Report Lisa-owned artifacts this apply chose not to replace.
+     *
+     * Reported as good news, not as a warning about the project: keeping a guard
+     * that is stronger than Lisa's is the correct outcome, and phrasing it as a
+     * problem would push an operator to "fix" it by discarding their own
+     * hardening — the exact loss the check exists to prevent.
+     */
+    printHostAheadDetail() {
+        if (this.counters.hostAhead === 0)
+            return;
+        const { logger } = this.deps;
+        logger.info(`${this.counters.hostAhead} Lisa-owned file(s) look stronger in your project than in Lisa, so your version was kept:`);
+        for (const note of this.hostAheadNotes) {
+            logger.info(`  ${note}`);
+        }
+        logger.info("Nothing is broken. Lisa only replaces one of its own files when it can prove your copy came from an older Lisa.");
+    }
     /**
      * Print summary statistics
      */