@clear-capabilities/agentic-security-scanner 0.195.23 → 0.195.24

package/CHANGELOG.md

@@ -9,6 +9,19 @@
 > make the history less accurate, not more.
 
 
+## 0.195.24 - GA programme, release D: lineage sources the taint engine does not own, seeds that survive an alias and a call
+
+GA-03.1 of the GA plan asked for the lineage corpus to be re-run on today's source, each failure classified, the source-category omissions closed without broadening the main taint catalog incorrectly, and aliasing and field identity fixed across calls. The corpus (`bench/data-lineage/`) now passes 24 of 24, all regression-tier, from 17 of 24 with seven capability-tier failures. Nothing moved a maturity: Code Boundaries stays Preview, because the real-code graph precision and recall of the frozen protocol (GA-02) are still unmeasured.
+
+- **A lineage-only source catalog** (`scanner/src/lineage/lineage-source-catalog.js`). Four of the fourteen reachable source categories had no JavaScript entry in the taint catalog (`cli-argument`, `http-upload`, `storage-read`, `user-input`), so the four corpus fixtures naming them were written in Python syntax and could never mint a source node. Six JavaScript entries now serve them (`process.argv`, `req.file`, `req.files`, `fs.readFileSync`, bare `prompt()`, `readlineSync.question()`), consulted by `source-seeding.js` after the main matcher, for JavaScript and TypeScript files only. They live beside the taint catalog, not in it, the way the privacy sink catalog does: a file's contents and a console prompt are where personal data enters a program, which the lineage graph records, but treating them as attacker-controlled would turn every configuration read into a taint source. A test pins that the main matcher returns null for every shape, and the self-scan, mutation and layer-recall gates are unchanged.
+- **Seeds after a call-shaped assignment.** A source that is a call (`const record = fs.readFileSync(p)`, `const data = res.json()`) has no access path, and until now was recorded as unseedable. It is seeded on the assignment target in the state leaving that node (`after-node` seeds, applied by the engine's worklist), so the value exists where the program puts it. A call-shaped source nested in another call's arguments is still unseedable, and still recorded.
+- **Seeds across an alias.** `const body = req.body; body.card_number` seeded the container and minted an unclassified element named `body`. The planner now follows the alias within the function and mints the field seed on the original path, so the flow carries `card_number` as PCI. Chained aliases are followed for at most four rounds; a dynamic key is never seeded; a parameter is never an alias.
+- **Seeds under every call context.** A field read in a helper and returned to the caller produced the right nodes and element and zero flows, because the caller resolved the helper under the state its arguments bound and the helper's own seed was absent from it. The call-summary resolver now joins the callee's own seeds onto that state: a source read inside a function is a fact about that function wherever it is called from. The cache rule of `DESIGN_GRAPH_BUILDER.md` section 3.6 stands, keyed by the joined state so nothing is ever stored under the empty-entry key for a seeded function; section 3.8 records the revision and the driver test pins both directions.
+- **The runner's contract** gained `expectUnsupportedSink` (the `exec` fixture's process-kind node with a reason, AC-11) and reads an empty `dataClass` label as "match on the categories alone" (a positional argument, a file's contents). The user-input fixture was renamed `js-user-input-to-log-pii` once its element had a name to classify. Every fixture's notes record what changed and how it was measured.
+- **Open, measured and pinned:** a sink inside a callee never sees an argument's identity, because a bare call statement is not resolved through the summary. Resolving it was tried and reverted: it consumes a summary context per call site and under a tight context cap degrades a later resolution, which moved seven pinned provenance measurements. `seeding-across-calls.test.js` pins the zero so the gap is measured, not assumed.
+
+Gates, from the runs recorded for this entry: `test:lineage` 1570/1570 (one new file, `seeding-across-calls.test.js`, wired into the scope), `test:lifecycle` 491/491, `bench:data-lineage:check` 24/24, `bench:self-scan:check` no drift (683/106/21/0), `bench:mutation:check` every verdict correct, `bench:layer-recall:check` unchanged. The 0.195.23 ship stopped once in the checks phase: the hosted macOS runner never picked up `determinism-attest (macos-latest)` on three attempts during a GitHub Actions incident (every other job green); after GitHub's mitigation a resume passed it on the next attempt. Measured 0.195.23 `TIMINGS`: `preflight=4s push=7s pr=6s checks=77s merge=6s verify=6s tag=2s release=255s npm=756s total=1119s release-clock=269s` (the checks figure is the resumed run; the first attempt spent 3644 s waiting on the runner).
+
 ## 0.195.23 - GA programme, release C: one model transport, reviewed rule promotion, metrics with a scope, provenance that proves absence, fleet results that age
 
 **Measured, 0.195.22:** `TIMINGS preflight=3s push=6s pr=4s checks=398s merge=5s verify=6s tag=2s release=161s npm=206s total=791s release-clock=174s`, shipped in 14 min 56 s on the second attempt (the first was stopped by the background gate's `ci-parity` check: a new deep-mode pin skipped under the hosted-CI switches until it set `DEEP_IN_CI` like the existing helper).

package/dist/3596.index.js

@@ -10,7 +10,7 @@ export const modules = {
 /* harmony export */ });
 /* unused harmony export HS_SWEEP_VERSION */
 /* harmony import */ var _dataflow_catalog_haskell_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(7225);
-/* harmony import */ var _lineage_source_seeding_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(88383);
+/* harmony import */ var _lineage_source_seeding_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(95174);
 // Root-cause sweep for Haskell (X-008). The generic sweep anchors on a `callee(args)` text shape, which Haskell's
 // juxtaposition syntax never produces, so a confirmed Haskell finding swept nothing. This sweep works on the IR: for
 // each confirmed finding it takes the RESOLVED sink callee from the model catalog and lists every other call of that