@clear-capabilities/agentic-security-scanner 0.151.3 → 0.152.0

package/src/dataflow/incremental.js

@@ -149,6 +149,18 @@ export function seedSummaryCache(summaryCache, persisted, reusableQids) {
     const summary = {
       returnTainted: !!s.returnTainted,
       mutatedParams: new Set(s.mutatedParams || []),
+      // W5.53: mutatedThisFields is a THIRD Set-valued summary field
+      // (object-instance field taint via method calls), added after this
+      // module's own serialize/reseed pair was written — omitting it here
+      // wouldn't crash (every consumer already null-guards with `&&`), but
+      // would silently drop the capability on any incremental/warm-cache
+      // scan, exactly the class of gap `_summaryEq`'s own header comment in
+      // summaries.js warns about for a different (but structurally
+      // identical) reason: a summary field that exists on some code paths
+      // and not others must be threaded through EVERY path that copies the
+      // summary shape, not just the ones exercised by this session's own
+      // tests.
+      mutatedThisFields: new Set(s.mutatedThisFields || []),
       taintedGlobals: new Set(s.taintedGlobals || []),
       findings: Array.isArray(s.findings) ? s.findings : [],
     };
@@ -195,6 +207,7 @@ export function serializeSummaries(summaryCache) {
     out[qid] = {
       returnTainted: !!summary.returnTainted,
       mutatedParams: [...(summary.mutatedParams || [])],
+      mutatedThisFields: [...(summary.mutatedThisFields || [])],
       taintedGlobals: [...(summary.taintedGlobals || [])],
       findings: Array.isArray(summary.findings) ? summary.findings.slice(0, 50) : [],
     };

package/src/dataflow/index.js

@@ -2,7 +2,7 @@
 import { runTaintEngine } from './engine.js';
 import { annotateProvenClean } from './proven-clean.js';
 import { CATALOG, matchSource, matchSinkOrSanitizer, _catalogSize } from './catalog.js';
-import { applyPathFeasibility } from './path-feasibility.js';
+import { applyPathFeasibility, buildConstantFnMap } from './path-feasibility.js';
 import { SummaryCache, entryStateFromCall } from './summaries.js';
 import { rhsReachableFunctions, shouldAnalyzeUnderRhs } from './tabulation.js';
 import { annotateBackwardSlices } from './backward.js';
@@ -12,7 +12,7 @@ import {
   serializeSummaries, commitIncrementalState,
 } from './incremental.js';
 import { buildPointsTo } from './points-to.js';
-import { buildClassHierarchy } from '../ir/class-hierarchy.js';
+import { buildClassHierarchy, annotateRTA } from '../ir/class-hierarchy.js';
 import { annotateSoftTaint } from './soft-taint.js';
 import { runIfdsTaintEngine } from './ifds.js';
 import { proveExploits } from './exploit-prover.js';
@@ -22,9 +22,13 @@ import { runPrivacyTaintEngine } from './privacy-deep-walker.js';
 
 export function runDeepAnalysis(perFileIR, callGraph, opts = {}) {
   // Path-feasibility pass over every function before the taint walk.
+  // W2.1: build the trivially-constant-helper map ONCE, from every function
+  // in the scan, before folding any single function's conditions — a
+  // constant helper in file A must resolve when called from file B.
+  const constFns = buildConstantFnMap(callGraph.functions.values());
   let totalPruned = 0;
   for (const fn of callGraph.functions.values()) {
-    const r = applyPathFeasibility(fn);
+    const r = applyPathFeasibility(fn, constFns);
     totalPruned += r.pruned;
   }
   // P2.1 — RHS-lite reachability slice. When AGENTIC_SECURITY_RHS=1 the
@@ -93,7 +97,16 @@ export function runDeepAnalysis(perFileIR, callGraph, opts = {}) {
   // (a single walk of the already-parsed IR, no fixed-point iteration) and
   // every consumer degrades to today's behavior when it finds no useful type.
   let classHierarchy = null;
-  try { classHierarchy = buildClassHierarchy(perFileIR); } catch { classHierarchy = null; }
+  try {
+    classHierarchy = buildClassHierarchy(perFileIR);
+    // PRD W2.5 (SARD_80_F1_EXECUTION_PRD.md) — RTA-annotate so
+    // `engine.js`'s `_resolveMemberCalleeViaCHA` can resolve a
+    // parameter-typed (or otherwise non-`new`-tracked) receiver against
+    // whichever subclasses are ACTUALLY instantiated somewhere in this
+    // scan, not just the receiver's own declared/abstract type (which
+    // typically has no method BODY of its own to resolve to at all).
+    if (classHierarchy) annotateRTA(classHierarchy, perFileIR);
+  } catch { classHierarchy = null; }
   // v0.70 #2 — Steensgaard points-to / alias analysis. Built once before
   // the worklist, passed via opts so the engine can resolve aliased
   // mutations (`let a = obj; a.x = tainted; sink(obj.x)`).
@@ -237,4 +250,4 @@ export function runDeepAnalysis(perFileIR, callGraph, opts = {}) {
   return findings;
 }
 
-export { runTaintEngine, CATALOG, matchSource, matchSinkOrSanitizer, _catalogSize, applyPathFeasibility, SummaryCache, entryStateFromCall, rhsReachableFunctions, shouldAnalyzeUnderRhs, annotateBackwardSlices };
+export { runTaintEngine, CATALOG, matchSource, matchSinkOrSanitizer, _catalogSize, applyPathFeasibility, buildConstantFnMap, SummaryCache, entryStateFromCall, rhsReachableFunctions, shouldAnalyzeUnderRhs, annotateBackwardSlices };

package/src/dataflow/path-feasibility.js

@@ -14,21 +14,84 @@
 //
 // Patterns deliberately deferred (would need SMT or symbolic execution):
 //   - Comparisons of unrelated variables
-//   - Comparisons involving function call return values
 //   - Aliasing-aware constraint propagation
+//   - Static/instance final-field constants (PRD W2.1's other half — needs
+//     parser changes to capture field initializer values across all IR
+//     languages, not attempted here)
+//
+// W2.1: trivially-constant helper returns. Juliet's control-flow-gating
+// variants (02-22) commonly gate through a helper — `if (privateReturnsTrue())`,
+// `if (IO.staticReturnsTrueOrFalse())` — rather than an inline literal. This
+// is NOT a Juliet-specific special case: `buildConstantFnMap` (below, called
+// once per scan in dataflow/index.js) generically finds any function whose
+// ENTIRE body is `return <literal>;` and nothing else, for ANY codebase,
+// then this module resolves a call to such a function the same way it
+// already resolves `if (true)`. A function with real logic (even one extra
+// statement) is never treated as constant — this reads the function's own
+// semantics, not an answer-key label.
 //
 // Output: mutates the CFG node's `succ` array to drop unreachable edges. The
 // existing taint engine then never walks them. Logs the prune count on each
 // function so we can count how many FPs path-feasibility avoided.
 
-function evalConst(expr) {
+// A function is "trivially constant" iff its CFG, after stripping entry/exit/
+// noop bookkeeping nodes, is exactly one `return <literal>;` node. Anything
+// else (a branch, an assignment, a call, a non-literal return) disqualifies
+// it — conservative by design, since a false resolution here silently prunes
+// a REAL branch.
+function triviallyConstantValue(fn) {
+  if (!fn || !fn.cfg || !fn.cfg.nodes) return undefined;
+  const real = Object.values(fn.cfg.nodes).filter(n => n && n.kind !== 'entry' && n.kind !== 'exit' && n.kind !== 'noop');
+  if (real.length !== 1) return undefined;
+  const only = real[0];
+  if (only.kind !== 'return') return undefined;
+  if (!only.value || only.value.kind !== 'literal') return undefined;
+  return only.value.value;
+}
+
+// Builds { byQid: Map<qid, value>, byBareName: Map<lastSegment, value|AMBIGUOUS> }
+// from every function in the scan. Bare-name resolution is how the hand-rolled
+// parsers' flat dotted-string callees (`"IO.staticReturnsTrue"`,
+// `"privateReturnsTrue"`) get matched — same collision-refusal precedent as
+// `callgraph.js`'s `~bare~` key: two differently-valued same-named functions
+// refuse to resolve via bare name rather than guessing.
+const AMBIGUOUS = Symbol('ambiguous-constant-fn');
+
+export function buildConstantFnMap(functions) {
+  const byQid = new Map();
+  const byBareName = new Map();
+  for (const fn of functions) {
+    const val = triviallyConstantValue(fn);
+    if (val === undefined) continue;
+    if (fn.qid) byQid.set(fn.qid, val);
+    const bare = (fn.name || '').split('.').pop();
+    if (!bare) continue;
+    if (byBareName.has(bare)) {
+      const existing = byBareName.get(bare);
+      if (existing !== AMBIGUOUS && existing !== val) byBareName.set(bare, AMBIGUOUS);
+    } else {
+      byBareName.set(bare, val);
+    }
+  }
+  return { byQid, byBareName };
+}
+
+function _bareCalleeName(callee) {
+  if (!callee) return null;
+  if (typeof callee === 'string') return callee.split('.').pop() || null;
+  if (callee.kind === 'ident') return callee.name || null;
+  if (callee.kind === 'member') return callee.prop || null;
+  return null;
+}
+
+function evalConst(expr, constFns) {
   if (!expr) return undefined;
   switch (expr.kind) {
     case 'literal': return expr.value;
     case 'unknown': return undefined;
     case 'binary': {
-      const l = evalConst(expr.left);
-      const r = evalConst(expr.right);
+      const l = evalConst(expr.left, constFns);
+      const r = evalConst(expr.right, constFns);
       if (l === undefined || r === undefined) return undefined;
       switch (expr.op) {
         case '===': return l === r;
@@ -47,10 +110,10 @@ function evalConst(expr) {
       return undefined;
     }
     case 'logical': {
-      const l = evalConst(expr.left);
+      const l = evalConst(expr.left, constFns);
       if (l === undefined) return undefined;
-      if (expr.op === '&&') return l ? evalConst(expr.right) : l;
-      if (expr.op === '||') return l ? l : evalConst(expr.right);
+      if (expr.op === '&&') return l ? evalConst(expr.right, constFns) : l;
+      if (expr.op === '||') return l ? l : evalConst(expr.right, constFns);
       return undefined;
     }
     case 'ident': {
@@ -62,6 +125,20 @@ function evalConst(expr) {
       // x === x style: the engine can't fold this without symbolic equality.
       return undefined;
     }
+    case 'call': {
+      // W2.1: a call to a function whose entire body is `return <literal>;`
+      // resolves to that literal — see `buildConstantFnMap` above. Prefer an
+      // exact qid match (rare for hand-rolled parsers' flat callee strings,
+      // but free to check), fall back to the collision-refused bare-name map.
+      if (!constFns) return undefined;
+      if (typeof expr.callee === 'string' && constFns.byQid.has(expr.callee)) {
+        return constFns.byQid.get(expr.callee);
+      }
+      const bare = _bareCalleeName(expr.callee);
+      if (!bare) return undefined;
+      const v = constFns.byBareName.get(bare);
+      return v === AMBIGUOUS ? undefined : v;
+    }
   }
   return undefined;
 }
@@ -77,7 +154,7 @@ function syntacticallyEqual(a, b) {
   return false;
 }
 
-export function applyPathFeasibility(fn) {
+export function applyPathFeasibility(fn, constFns) {
   if (!fn || !fn.cfg || !fn.cfg.nodes) return { pruned: 0 };
   let pruned = 0;
   for (const id of Object.keys(fn.cfg.nodes)) {
@@ -86,7 +163,7 @@ export function applyPathFeasibility(fn) {
     const cond = node.cond;
     if (!cond) continue;
     // Constant cond?
-    const val = evalConst(cond);
+    const val = evalConst(cond, constFns);
     if (val === true) {
       // Drop the second successor (the false branch).
       if (node.succ.length > 1) {

package/src/dataflow/string-domain.js

@@ -232,3 +232,135 @@ export function isSafeRedirectTarget(absVal, allowedHosts) {
 export function hashAbstract(absVal) {
   return render(absVal);
 }
+
+/**
+ * Next-gen taint capability #2 — regex-VALIDATION guard safety.
+ *
+ * A DIFFERENT question from `provablyMatches` above (which asks "does this
+ * already-known abstract value fit a safety regex"): here we're asked "is
+ * this REGEX PATTERN, used as a `pattern.test(x)`-style validation guard,
+ * restrictive enough that observing it MATCH on the true branch proves `x`
+ * cannot carry injection metacharacters for ANY family?" This is the JS/TS
+ * analog of PHP's `if (preg_match($re, $x) == 1) { ... }` idiom — found to
+ * be a genuine, real-world-common pattern with NO recognition anywhere in
+ * this engine (neither the name-based `GUARD_PREDICATES` in engine.js, nor
+ * this file's own `abstract()`/`SANITIZER_OUTPUT_REGEX`, which characterizes
+ * a SANITIZER CALL's output, not a validation-guard's CONDITION).
+ *
+ * Deliberately a conservative ALLOWLIST parser, not a full regex-engine
+ * subset check (undecidable in general): walks the pattern character by
+ * character, permitting only literal safe characters (letters, digits, and
+ * a short vetted punctuation set), `\d`/`\w` shorthand classes, and
+ * bracket character classes built from the same safe set — with
+ * quantifiers on any of the above. Anything it cannot fully account for
+ * (alternation, groups, wildcards, negated classes `[^...]`, negated
+ * shorthand `\D`/`\W`/`\s`/`\S`, backreferences, lookaround, unicode
+ * property escapes, an unescaped stray metacharacter) REJECTS rather than
+ * guesses — a false "safe" here would silently suppress a real,
+ * exploitable finding, which is a much worse failure mode than missing a
+ * genuinely-safe-but-unrecognized pattern (the existing, unchanged taint
+ * flow still fires in that case, exactly as it did before this capability
+ * existed).
+ *
+ * Also requires full anchoring (`^...$`) and rejects the `m` (multiline)
+ * flag: with `m` set, `^`/`$` match at LINE boundaries rather than string
+ * boundaries, so a multi-line input could have a safe first line and an
+ * unsafe second line while still matching `^safe$` against line one —
+ * silently defeating the "matched, therefore the WHOLE value is safe"
+ * guarantee this function exists to provide.
+ */
+export function isSafeValidationPattern(pattern) {
+  if (!(pattern instanceof RegExp)) return false;
+  if (pattern.flags && pattern.flags.includes('m')) return false;
+  const source = pattern.source;
+  if (!source.startsWith('^') || !source.endsWith('$')) return false;
+  const body = source.slice(1, -1);
+  if (!body) return false; // `^$` (empty-string-only) is degenerate, not a useful guard
+  // Two DISTINCT allowlists, deliberately not merged into one — conflating
+  // them is exactly the bug this comment now documents (caught by this
+  // function's own adversarial unit tests before ever reaching production):
+  //
+  // `isSafeBareChar` — characters with NO special regex meaning when they
+  // appear UNESCAPED. Critically, `.` (the wildcard metacharacter — matches
+  // ANY character) is NOT in this set: an earlier version of this function
+  // included `.` here on the (wrong) assumption that it's "just punctuation,"
+  // which caused `/^.*$/` — the real PHP generator's OWN "no_filtering"
+  // unsafe sample, matching literally everything — to be accepted as a safe
+  // guard. A bare `.` in a pattern is ALWAYS the wildcard; a literal dot
+  // must be escaped (`\.`) or appear inside a character class (`[.]`),
+  // both handled by the escaped/class-content paths below.
+  //
+  // `isSafeEscapedPunct` — punctuation that, when ESCAPED with a backslash,
+  // unambiguously means "match this literal character." Deliberately
+  // EXCLUDES every letter and digit: an escaped letter in regex syntax is
+  // Two DELIBERATELY SEPARATE allowlists, keyed by context, not merged into
+  // one — conflating them is the exact bug class this function's own
+  // adversarial unit tests caught twice while writing it, both fixed here:
+  //
+  // `isSafeBareChar` (governs an UNESCAPED character, bare or inside a
+  // class) — letters, digits, underscore, hyphen, at-sign: characters with
+  // NO special regex meaning at all when unescaped. Crucially this does
+  // NOT include `.` — a bare `.` outside a class is the wildcard
+  // metacharacter (matches ANY character), not punctuation. An earlier
+  // version of this allowlist included `.`, which let `/^.*$/` — the real
+  // PHP generator's own "no_filtering" UNSAFE sample, matching literally
+  // everything — pass as a safe guard.
+  //
+  // `isSafeEscapedChar` (governs a character immediately AFTER a
+  // backslash) — punctuation ONLY, deliberately excluding every letter and
+  // digit. An escaped letter in regex syntax is NEVER a plain literal:
+  // `\d`/`\D`/`\w`/`\W`/`\s`/`\S`/`\b`/`\B` are shorthand/boundary
+  // constructs, `\1`/`\2`/… are backreferences, and any other escaped
+  // letter could be a unicode property escape (`\p{...}`) or named
+  // backreference this parser has never heard of. An earlier version of
+  // this function reused `isSafeBareChar` (which includes letters) for the
+  // escaped-character check too, so `\D` (negated digit — matches almost
+  // anything) was accepted as though it meant a literal capital D.
+  const isSafeBareChar = (ch) => /^[a-zA-Z0-9_\-@]$/.test(ch);
+  const isSafeEscapedChar = (ch) => /^[_\-@.]$/.test(ch);
+  let i = 0;
+  const consumeQuantifier = () => {
+    if (i >= body.length) return;
+    const ch = body[i];
+    if (ch === '*' || ch === '+' || ch === '?') { i++; return; }
+    if (ch === '{') {
+      const close = body.indexOf('}', i);
+      if (close === -1) throw new Error('unterminated');
+      if (!/^\d+(,\d*)?$/.test(body.slice(i + 1, close))) throw new Error('malformed');
+      i = close + 1;
+    }
+  };
+  try {
+    while (i < body.length) {
+      const ch = body[i];
+      if (ch === '\\') {
+        const next = body[i + 1];
+        if (next === 'd' || next === 'w') { i += 2; consumeQuantifier(); continue; }
+        if (next && isSafeEscapedChar(next)) { i += 2; consumeQuantifier(); continue; }
+        return false; // \D, \W, \s, \S, \b, an escaped letter/digit, unicode escapes, or anything unrecognized
+      }
+      if (ch === '[') {
+        const close = body.indexOf(']', i);
+        if (close === -1) return false;
+        const cls = body.slice(i + 1, close);
+        if (cls.startsWith('^')) return false; // negated class — "anything except", unsafe by construction
+        let j = 0;
+        while (j < cls.length) {
+          if (cls[j] === '\\' && (cls[j + 1] === 'd' || cls[j + 1] === 'w')) { j += 2; continue; }
+          if (cls[j] === '\\' && isSafeEscapedChar(cls[j + 1])) { j += 2; continue; }
+          // Inside a character class, `.` loses its wildcard meaning and IS
+          // a literal dot even when bare — no escaping needed here, unlike
+          // outside a class.
+          if (isSafeBareChar(cls[j]) || cls[j] === '-' || cls[j] === '.') { j++; continue; }
+          return false;
+        }
+        i = close + 1;
+        consumeQuantifier();
+        continue;
+      }
+      if (isSafeBareChar(ch)) { i++; consumeQuantifier(); continue; }
+      return false; // `.`, `|`, `(`, `)`, a bare mid-pattern `^`/`$`, or any other metacharacter
+    }
+  } catch { return false; }
+  return true;
+}

package/src/dataflow/summaries.js

@@ -91,9 +91,26 @@ export class SummaryCache {
   _key(qid, taintedParams, receiverType) {
     // P1.2: when a receiver type is provided, extend the cache key with
     // its hash. Backward-compatible: no receiverType → same key as before.
-    let base = `${qid}::${_hashState(taintedParams)}`;
-    // R2: append the caller qid when call-string sensitivity is enabled.
-    if (this._callString && this._callerCtx) base = `${base}@${this._callerCtx}`;
+    const stateHash = _hashState(taintedParams);
+    let base = `${qid}::${stateHash}`;
+    // R2: append the caller qid when call-string sensitivity is enabled —
+    // but ONLY for a NON-EMPTY entry state. The EMPTY-entry baseline is the
+    // one summary `engine.js`'s outer fixed-point pre-pass loop shares and
+    // progressively refines across BOTH multiple passes AND every call path
+    // that reaches a function with no tainted args — splitting it by caller
+    // breaks that sharing outright: a 3-hop empty-entry mutation chain
+    // (leaf mutates its own param unconditionally, mid calls leaf, top calls
+    // mid) stopped propagating entirely once enabled, confirmed via direct
+    // instrumentation, not a hypothetical concern — the pre-pass loop's own
+    // `bMid`/`cLeaf` iterations write to a caller-LESS key nothing else ever
+    // reads once a NESTED call from a different caller starts writing to a
+    // caller-SUFFIXED key instead. A non-empty entry state has no such
+    // shared-convergence dependency to begin with — the value-context cache
+    // (`AGENTIC_SECURITY_KCFA_MAX_CONTEXTS`) already computes each distinct
+    // tainted-arg shape independently, lazily, per call site, so adding a
+    // caller dimension there only ever narrows an already-isolated lookup,
+    // never disconnects a shared one.
+    if (this._callString && this._callerCtx && stateHash !== 'empty') base = `${base}@${this._callerCtx}`;
     if (!receiverType) return base;
     return `${base}::${hashReceiverType(receiverType)}`;
   }
@@ -103,7 +120,8 @@ export class SummaryCache {
   }
 
   set(qid, taintedParams, summary, receiverType) {
-    this._cache.set(this._key(qid, taintedParams, receiverType), summary);
+    const k = this._key(qid, taintedParams, receiverType);
+    this._cache.set(k, summary);
   }
 
   has(qid, taintedParams, receiverType) {
@@ -172,8 +190,16 @@ export class SummaryCache {
   // Helper: apply a summary to a caller's taint state given the call site's
   // argument bindings. Returns { calleeReturnTainted, mutated: Set of caller-side
   // var names that should become tainted because the callee mutated them }.
-  applyAtCallSite(summary, paramNames, callArgs, callerTaintedVars) {
-    if (!summary) return { returnTainted: false, mutated: new Set() };
+  // `receiverPath` (optional, next-gen taint capability #3): the caller-side
+  // access path of a receiver-qualified call's OWN receiver (`bad` for
+  // `bad.setData(x)`). When present and `summary.mutatedThisFields` is
+  // non-empty, also returns `mutatedThisPaths` — the receiver's own field
+  // paths (`bad.data`) to taint in the caller, mirroring `mutated` above but
+  // for the implicit `this` parameter instead of a declared one. Omitting
+  // `receiverPath` (every pre-existing call site) leaves `mutatedThisPaths`
+  // empty, so this is purely additive for callers that don't pass it.
+  applyAtCallSite(summary, paramNames, callArgs, callerTaintedVars, receiverPath) {
+    if (!summary) return { returnTainted: false, mutated: new Set(), mutatedThisPaths: new Set() };
     const mutated = new Set();
     if (summary.mutatedParams && summary.mutatedParams.size) {
       // Map each mutated parameter position back to the caller-side argument name.
@@ -184,7 +210,11 @@ export class SummaryCache {
         if (arg && arg.kind === 'ident') mutated.add(arg.name);
       }
     }
-    return { returnTainted: !!summary.returnTainted, mutated };
+    const mutatedThisPaths = new Set();
+    if (receiverPath && summary.mutatedThisFields && summary.mutatedThisFields.size) {
+      for (const field of summary.mutatedThisFields) mutatedThisPaths.add(`${receiverPath}.${field}`);
+    }
+    return { returnTainted: !!summary.returnTainted, mutated, mutatedThisPaths };
   }
 
   size() { return this._cache.size; }
@@ -208,6 +238,16 @@ function _summaryEq(a, b) {
   const bm = b.mutatedParams || new Set();
   if (am.size !== bm.size) return false;
   for (const p of am) if (!bm.has(p)) return false;
+  // Next-gen taint capability #3's `mutatedThisFields` is a THIRD summary
+  // field alongside `returnTainted`/`mutatedParams` — deliberately compared
+  // here too, not left out, per this function's own header comment above:
+  // omitting a field from this equality check is exactly how a fresher,
+  // more-refined summary can be silently discarded by the fixed-point loop
+  // while still being returned to its immediate caller.
+  const atf = a.mutatedThisFields || new Set();
+  const btf = b.mutatedThisFields || new Set();
+  if (atf.size !== btf.size) return false;
+  for (const f of atf) if (!btf.has(f)) return false;
   return true;
 }
 
@@ -244,10 +284,31 @@ export function entryStateFromCall(paramNames, callArgs, callerTaintedVars, isAr
     // ASSIGNED locals, not raw globals) took the member branch, found
     // nothing, and — being an else-if — never reached isArgTaintedExpr at
     // all. Confirmed via a real corpus fixture.
+    // PRD W2 (SARD_80_F1_EXECUTION_PRD.md) — an object argument whose FIELD
+    // was tainted before the call (`c.field = tainted; step(c);`) is a
+    // documented scope gap: entry-state granularity here is param-level,
+    // not per-access-path, so `c` itself was never marked tainted even
+    // though `c.field` genuinely is in the caller's field-sensitive lattice
+    // — the callee then reads `c.field` back out with no provenance at all.
+    // Found sampling real Juliet variant 67 false negatives (a tainted
+    // value stored into a `Container` object's field, the object passed
+    // whole to another function, the field read back out there). Widens
+    // the SAME direction this codebase already takes for "unknown-key
+    // container writes" and collection taint (dataflow/CLAUDE.md's own
+    // documented precedent): if ANY access path prefixed by this
+    // identifier is tainted, treat the whole object as tainted when it
+    // crosses a call boundary — over-approximating (a clean sibling field
+    // read downstream may falsely inherit taint) is the accepted direction
+    // for a security scanner, the same tradeoff every other "widen to the
+    // container" rule in this codebase already makes.
     let tainted = false;
     if (arg.kind === 'ident' && callerTaintedVars.has(arg.name)) {
       tainted = true;
-    } else if (arg.kind === 'member' && arg.object?.kind === 'ident') {
+    } else if (arg.kind === 'ident') {
+      const prefix = `${arg.name}.`;
+      for (const v of callerTaintedVars) { if (v.startsWith(prefix)) { tainted = true; break; } }
+    }
+    if (!tainted && arg.kind === 'member' && arg.object?.kind === 'ident') {
       const base = arg.object.name;
       if (callerTaintedVars.has(base) || callerTaintedVars.has(`${base}.${arg.prop}`)) tainted = true;
     }