circle-ir-ai 4.27.0 → 4.29.0

package/CHANGELOG.md

@@ -116,6 +116,176 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   Unchanged on 4.9.29: OWASP 1415/1415, Juliet 243/243, SecuriBench 97.2%/6.7%, Go 89.5%,
   NodeJS 92.9%, CWE-Bench-Rust 100%, bash and HTML 100%.
 
+## [4.29.0] - 2026-10-17
+
+Minor release: `circle-ir` 4.15.0 → 4.16.1, LLM enrichment sinks anchored on the `scan --llm`
+merge path, and corrected SecuriBench and C# oracle scoring. 4.16.0 was not pinned: it carried
+four regressions, fixed upstream in 4.16.1 before this bump.
+
+### Changed
+- **`circle-ir` 4.15.0 → 4.16.1** (exact pin). 4.16.0 adds the navigation API (callers per
+  overload and through dispatch), `navigationTypes` extraction, `AnalyzerOptions.resources`, and
+  many recall and precision fixes across Java, C#, JS/TS, Go, Python and Rust. 4.16.1 fixes four
+  regressions found while benchmarking this bump. Java `analyze()` is back to 4.15.0 speed on
+  large classes (one NiFi file took 638 s on 4.16.0 and 0.83 s on 4.16.1; cognium-dev#806). A
+  `Character.is*` predicate on tainted text is no longer an `external_taint_escape`, which clears
+  SecuriBench Sanitizers2/6 (cognium-dev#807). Two C# false positives are fixed: a field
+  sanitized in another method (cognium-dev#808) and an `Array.IndexOf` allowlist guard
+  (cognium-dev#809). The underlying Java name-collision cause of #807 is cognium-dev#814.
+
+  Static suites, compared with 4.15.0 (packed 4.16.1, 27 runners):
+  - SecuriBench 97.2% / 6.7% → 97.7% / 6.7%;
+  - C# oracle 76.6% / 0.8% (3/367) → 77.1% / 0.3% (1/367);
+  - CWE-Bench-Java static 64 → 65 of 120;
+  - Python synthetic 72.2% → 74.0%;
+  - Vulnerability-goapp FPR 14.3% → 0.0%;
+  - the other 21 identical.
+
+  Figures before the scoring changes below.
+
+### Fixed
+- **LLM enrichment sinks are anchored in `runMerge`** (#330). The `scan --llm` merge path now
+  applies `resolveDiscoveryAnchor`, so an enrichment sink lands on a call node or carries
+  `llm-unanchored`, as in discovery mode. `runPatternMatch` forwards the IR calls for anchoring,
+  and LLM sinks merge on their post-anchor key.
+- **SecurityScanner test-tree excludes (cognium-ai#615)**. The engine walker no longer uses
+  unanchored `**/test/**` / `**/tests/**`, which also matched a Java package segment named
+  `test` under main source. It now mirrors the `init` template: `test/**`, `tests/**`,
+  `**/src/test/**`, `**/__tests__/**`.
+
+### Benchmarks
+- **SecuriBench Micro labels.** The runner read only the `@servlet vuln_count` annotation. Where
+  that annotation contradicts both `getVulnerabilityCount()` and the `/* BAD */` markers, the
+  method and markers now win, and every disagreement is printed (`benchmarks/lib/securibench-labels.ts`).
+  - Overrides: `pred/Pred2.java` 0 → 1 (the suite's one FP was a true positive),
+    `collections/Collections10.java` 0 → 1, `inter/Inter10.java` 2 → 1.
+  - Six other disagreements keep the annotation, because the markers side with it.
+  - On circle-ir 4.16.1: **TPR 97.3%, FPR 0.0%** (107/110, 0/13). With the old labels it was
+    97.7% / 6.7% (105/108, 1/15).
+- **C# oracle clean controls are scored against their category's taint sinks**
+  (`cleanScope()`, `benchmarks/lib/csharp-oracle-scoring.ts`).
+  - A placeholder `category: "clean"` case resolves through its paired `*Tp.cs`.
+  - 33 controls for a non-taint signal (for example `IncorrectDefaultPermsSafe.cs`, the
+    CWE-276 twin) leave the denominator.
+  - 95 general-FP or unmapped cases keep the any-flow rule.
+  - On circle-ir 4.16.1: **TPR 77.1% (340/441), FPR 0.0% (0/334)**.
+
+## [4.28.0] - 2026-10-15
+
+Minor release: `circle-ir` 4.14.2 → 4.15.0, discovery prompts carry line numbers, verifier
+refutations get their own label, and skill-detector fixes. Includes 4.27.1, which was not
+published on its own.
+
+### Changed
+- **`circle-ir` 4.14.2 → 4.15.0** (exact pin). A precision release upstream: new sources
+  (Express destructured requests, GraphQL resolver-map arguments) and sinks (Spring handlers
+  returning request input as HTML, `loadClass` on context class loaders), and many cleared false
+  positives (const-origin `fetch` ssrf, const-only `RegExp` redos, `JSON.stringify` and C# hashes
+  or dictionary lookups as `external_taint_escape`, length/count/boolean tests of tainted text).
+  See circle-ir's changelog for the list.
+
+### Fixed
+- **Skill code-threat detectors judge a comment by the file's own comment syntax** (cognium-ai#647
+  §1, follow-up to #648/#653). `isCommentOrDoc`, the trailing-comment cut and the #352 block mask
+  used the union of every language's openers, so real code passed as a comment and every detector
+  skipped it: Python `n = 4 // 2; os.system(…)` (floor division), Python `note: int = …` and JS
+  `example: execSync(…)` (an annotated assignment and a label, read as `Note:` / `Example:` prose),
+  Python `*_, = [os.system(…)]` and a JS generator method `* run() {…}` (read as JSDoc
+  continuations), shell `ls /*` (opened a block comment that masked the rest of the file) and
+  shell `echo ${#HOME}; curl … | bash` (a length expansion read as a `#` comment). Each hid a
+  `curl … | sh`. Python/shell/Ruby/YAML-family files now use `#` only (shell: at the start of a
+  word), C-family files `//` and `/* */`, PHP both; a file with no recognised extension
+  (SKILL.md, references) keeps the old union. Real comments and docstrings stay suppressed.
+- **Malformed model output no longer aborts or voids a skill scan in LLM mode** (cognium-ai#647
+  §2, follow-up to #648). `capability-mismatch` iterated the model's reply as-is: an object reply
+  threw "mismatches is not iterable" and a `null` entry threw on `.type`, and both escaped
+  `analyzeSkillBundle` as "Skill analysis failed", taking the deterministic findings with them.
+  `instruction-safety` threw on a numeric `severity` or non-string `evidence`, which turned a real
+  answer into "could not analyze". Entries with no type are dropped, other fields are coerced
+  (`sanitizeRawThreat`, exported).
+- **`cross_skill_interference` from the instruction-safety LLM needs another skill, plugin, tool
+  or agent as the target** (cognium-ai#415, the LLM half; the static half shipped in 4.25.0).
+  `downweightInstructionOverreads` floors the finding to `info` unless its quote passes the static
+  detector's governed-verb rule (`isCrossSkillImperative`, exported), with sibling-qualified tools,
+  agents and MCP servers also accepted. Both #415 repros ("These override the generic
+  file-writing … instructions below", "Remove the red-eye from this image") floor; "disable the
+  other installed skills" keeps its severity. Category 19 of the prompt now says the same.
+  Kill switch: `SKILL_INSTRUCTION_OVERREAD_GATE=0`.
+
+  skills-validation static gate (`.synced` adapter, `SKIP_INSTRUCTION=1`, oracle v21): 57/152
+  required types, 0 safe/benign fixtures with findings, before and after; byte-identical except
+  ordering. That adapter is not the one behind #647's 97/152 figure.
+- **A verifier refutation is no longer reported as "no verdict"** (cognium-ai#471). The batch
+  verifier prompt has the model omit every pair it does not judge a TRUE_POSITIVE. When a file's
+  answer held no TRUE_POSITIVE, `runReport` fell through to the static branch and kept every
+  detector finding with `verification.verdict: 'UNVERIFIED'`, which circle-pack maps to
+  `llm_result.verdict: 'UNCERTAIN'`. That is how 81,842 skill-scan findings showed 31%
+  TRUE_POSITIVE, 69% UNCERTAIN and no FALSE_POSITIVE: the refutations were there, under the wrong
+  label. Such a finding now carries `verdict: 'FALSE_POSITIVE'`, `refuted_by: 'omission'`,
+  `mode: 'llm'`, `llm_verified: false`. It is kept, not dropped, so finding counts do not change;
+  `exploitable` stays `false`, as it was for `UNVERIFIED`. The label applies only when the answer
+  is unambiguous: every pair behind the finding was submitted, none was in a failed chunk (#564
+  still keeps those open), no pair was dropped by the fan-out budget, and no returned pair failed
+  to map. Otherwise the finding stays `UNVERIFIED`. `ScanMeta.verification` gains
+  `findingsRefutedByOmission`, present only when non-zero. The prompt is unchanged. An explicit
+  FALSE_POSITIVE pair is still dropped by the verified branch, as before, so it never reaches a
+  finding. `tests/verifier-false-positive-471.test.ts` puts a stubbed FALSE_POSITIVE and an empty
+  `pairs` answer through the parser, `runReport` and `scanDirectory`.
+- **Discovery prompts show the line numbers they ask for** (#658). `DiscoveryEngine.analyzeMethod`
+  asked the model for an absolute `"line"` but sent the method code without line numbers, so the
+  model guessed file lines from the text; a guessed line is how a discovery finding lands on a
+  signature, a `throw` or a closing brace (#330). Each line of the method is now prefixed with
+  its file line number (`42 | …`), and the prompt says `line` must be one of those numbers. A
+  line-number prefix the model copies into `code` is stripped. The #657 anchoring (move onto a
+  call the snippet names, else `llm-unanchored`) stays as the safety net. The language
+  discoverers on the `scan --llm` path (`discoverSourcesForLanguage` /
+  `discoverSinksForLanguage`, called by `runEnrich`) had the same defect on the whole file and
+  get the same fix, numbered from line 1. The batch verifier already numbered its windows. The
+  user prompt is now built by the exported `buildDiscoveryUserPrompt`.
+
+### Changed
+- **Discovery cache key versions `disc-v3` → `disc-v4` and `lang-disc-v2` → `lang-disc-v3`**
+  (#658). Warm entries were answered from unnumbered code, so every local and R2 discovery entry
+  misses once and re-asks the model. The method cache key still holds no line numbers: an entry
+  now records the start line its prompt was numbered from, and a hit on a byte-identical method
+  elsewhere shifts its `line` and `source.line` by the difference before anchoring (before, a
+  hit kept the other method's lines and was clamped into this one).
+
+### Benchmarks (local, circle-ir 4.15.0)
+26 static suites run on 4.14.2 and 4.15.0 back to back, same source, same machine (2026-10-15).
+All 26 score identically: OWASP 1415/1415, Juliet 243/243, CWE-Bench-Java static 64/120
+(64/111 evaluable), secrets recall 100% / F1 98.2%, csharp-oracle and C# Juliet unchanged.
+4.15.0's fixes land on shapes these corpora do not contain. The openclaw `beam-session.js`
+redos (cognium-ai#671) still reports on 4.15.0: circle-ir #681 does not cover that file's
+pattern. No LLM benchmark was re-run for this release; #658's before/after discovery run on
+gemma3:12b is still outstanding.
+
+## [4.27.1] - 2026-10-14
+
+Patch release: one precision fix on the LLM scan path. `circle-ir` stays on 4.14.2.
+
+### Fixed
+- **The LLM scan path applies the same precision gates as `scan --no-llm`** (#460; PR #672).
+  `runReport` built its detector index (the no-verification findings and the #264 verify-parity
+  gate) with `generateFindings(sources, sinks, dfg, file)` only, so the non-executable-line gate,
+  sanitizer credit and the method-scoped proximity gate were all off. It now forwards
+  `sourceCode` and `types`, plus a new optional trailing `taintContext { language, sanitizers }`;
+  `PatternMatchResult` gains `sanitizers`. `flows` is still not forwarded, because in circle-ir it
+  also emits a finding per unsanitized flow (cognium-dev#372). An LLM-discovered pair that crosses
+  a function boundary, sits on a comment line or is covered by a sanitizer is now dropped, from
+  both the unverified output and the verify-parity gate.
+
+### Changed
+- **Tree-cache key version `tree-v1` → `tree-v2`.** Warm entries carry no sanitizers, so every
+  local and R2 tree-cache entry re-parses once. The cost is one parse per file; it makes no LLM
+  calls.
+
+### Benchmarks (local, gemma3:12b)
+A/B on 154 OWASP files, run 2026-10-11 before circle-ir 4.14.x and not repeated on 4.14.2: TP/FN
+67/10 → 70/7, FP/TN 40/37 → 39/38, findings 976 → 975, LLM calls 462 → 462 with 0 failures. One
+run per arm, so this is within LLM noise: no measured recall loss, no measured precision gain.
+The static suites do not exercise `runReport`.
+
 ## [4.27.0] - 2026-10-12
 
 Minor release: one change to which files `scan` analyses, and additive output fields.

package/dist/agents/mastra/instance.d.ts

@@ -190,7 +190,7 @@ export declare function createMastraInstance(options?: MastraInstanceOptions): {
                 reasoning: string;
             }, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "cross-file-taint", unknown>;
         }, undefined, any, import("@mastra/core/agent").AgentEditorConfig | undefined>;
-    }, Record<string, import("@mastra/core/workflows").AnyWorkflow>, Record<string, import("@mastra/core/vector").MastraVector<any>>, Record<string, import("@mastra/core/tts").MastraTTS>, import("@mastra/core/logger").IMastraLogger, Record<string, import("@mastra/core/mcp").MCPServerBase<any>>, Record<string, import("@mastra/core/evals").MastraScorer<any, any, any, any>>, Record<string, import("@mastra/core/tools").ToolAction<any, any, any, any, any, any, unknown>>, Record<string, import("@mastra/core/processors").Processor<any, unknown>>, Record<string, import("@mastra/core/memory").MastraMemory>, Record<string, import("@mastra/core/channels").ChannelProvider>, Record<string, import("@mastra/core/classifier").Classifier<any>>>;
+    }, Record<string, import("@mastra/core/workflows").AnyWorkflow>, Record<string, import("@mastra/core/vector").MastraVector<any>>, Record<string, import("@mastra/core/tts").MastraTTS>, import("@mastra/core/logger").IMastraLogger, Record<string, import("@mastra/core/mcp").MCPServerBase<any>>, Record<string, import("@mastra/core/evals").MastraScorer<any, any, any, any>>, Record<string, import("@mastra/core/tools").ToolAction<any, any, any, any, any, any, unknown>>, Record<string, import("@mastra/core/processors").Processor<any, unknown>>, Record<string, import("@mastra/core/memory").MastraMemory>, Record<string, import("@mastra/core/channels").ChannelProvider>, Record<string, import("@mastra/core/classifier").Classifier<any>>, Record<string, import("@mastra/core/knowledge").Knowledge>>;
     agents: {
         enrichment: import("@mastra/core/agent").Agent<"enrichment-agent", {
             classifyRole: import("@mastra/core/tools").Tool<{

package/dist/agents/mastra/workflow.d.ts

@@ -7,11 +7,12 @@
  * This module provides convenience functions for running the complete
  * analysis pipeline using the core analysis logic.
  */
-import type { DFG, ProjectProfile } from 'circle-ir';
+import type { DFG, ProjectProfile, TaintSanitizer } from 'circle-ir';
 import type { TypeShape } from '../../security-scan/source-classifier.js';
 import type { LLMConfig } from '../../llm/config.js';
 import type { PackageCoordinate } from '../../cache/coordinate.js';
 import { type ClusterVector } from '../../cluster/cluster.js';
+import { type AnchorCallNode } from '../../llm/anchoring.js';
 export { patternMatchStep, enrichStep, mergeStep, verifyStep, reportStep, } from './steps.js';
 export type VerificationStrategy = 'complete' | 'sampled' | 'prioritized';
 export interface WorkflowInput {
@@ -61,6 +62,12 @@ export interface WorkflowOutput {
         pairsFailed?: number;
         /** cognium-ai#564 — findings kept unverified because their chunk failed (`verification.verification_error`). */
         findingsUnverified?: number;
+        /**
+         * cognium-ai#471 — findings kept with `verification.verdict: 'FALSE_POSITIVE'`
+         * (`refuted_by: 'omission'`): every pair behind them was submitted to the
+         * verifier and omitted from a successful answer. Optional; absent means 0.
+         */
+        findingsRefutedByOmission?: number;
         /** cognium-ai#564 — the failure reason(s), present only when a chunk failed. */
         verificationError?: string;
         totalTimeMs: number;
@@ -91,7 +98,7 @@ export interface WorkflowOutput {
 }
 /** cognium-ai#591 — why `runEnrich` made no discovery call for a file. */
 export type EnrichmentSkipReason = 'prefilter' | 'minified';
-export declare function runMerge(patternSources: any[], patternSinks: any[], enrichmentResult: any | null, confidenceThreshold: number, sourceCode?: string, filePath?: string, types?: ReadonlyArray<TypeShape>, language?: string): {
+export declare function runMerge(patternSources: any[], patternSinks: any[], enrichmentResult: any | null, confidenceThreshold: number, sourceCode?: string, filePath?: string, types?: ReadonlyArray<TypeShape>, language?: string, irCalls?: ReadonlyArray<AnchorCallNode>): {
     mergedSources: any[];
     mergedSinks: any[];
 };
@@ -121,6 +128,29 @@ verifyAccounting?: {
     unverifiedPairs?: UnverifiedPair[];
     /** cognium-ai#564 — the failure reason, stamped as `verification_error`. */
     verificationError?: string;
+    /**
+     * cognium-ai#471 — every (source, sink) pair submitted to the verifier.
+     * With it, a static finding whose pairs were all submitted, none failed,
+     * and none came back is labelled `FALSE_POSITIVE` (refuted by omission —
+     * the batch prompt's contract) instead of `UNVERIFIED`. Optional: legacy
+     * callers omit it and keep the pre-#471 `UNVERIFIED` label.
+     */
+    submittedPairs?: UnverifiedPair[];
+}, 
+/**
+ * cognium-ai#460 — the rest of `generateFindings`' argument list. With
+ * only (sources, sinks, dfg, file) every precision gate is off: the
+ * non-executable-line gate (needs `sourceCode` + `language`), sanitizer
+ * credit, and the method-scoped proximity gate (`types`). The static
+ * scanner passes all of them; this makes the detector index — and so the
+ * #264 verify-parity gate — use the same gates. (`flows` is not forwarded:
+ * it would turn on cognium-dev#372 flow emission, an additive change.) Optional: legacy
+ * callers (tests) omit it and keep the pre-#460 behaviour, except that
+ * `types` / `sourceCode` (already parameters) are now forwarded too.
+ */
+taintContext?: {
+    language?: string;
+    sanitizers?: TaintSanitizer[];
 }): WorkflowOutput;
 /**
  * Run security analysis on a single file

package/dist/agents/mastra/workflow.d.ts.map

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

package/dist/agents/mastra/workflow.js

@@ -20,6 +20,7 @@ import { resetLLMCallLimiter, isSwarmActive } from '../../llm/call-limiter.js';
 import { resetLLMPerFileBreaker, resetLLMBreakerForScan } from '../../llm/ax-client.js';
 import { getTreeCache, computeTreeCacheKey, computeRuleSetFingerprint, } from '../../cache/tree-cache.js';
 import { extractClusterVector } from '../../cluster/cluster.js';
+import { resolveDiscoveryAnchor, } from '../../llm/anchoring.js';
 // Re-export the Mastra step definitions
 export { patternMatchStep, enrichStep, mergeStep, verifyStep, reportStep, } from './steps.js';
 // ============================================================================
@@ -135,6 +136,9 @@ coordinate) {
         // DFG/proximity gating + dedup-merge with provenance collapse,
         // replacing the previous N×M cross-product.
         dfg: result.dfg,
+        // cognium-ai#460 — sanitizers for `generateFindings` parity with
+        // the static scanner (see `runReport`'s `taintContext`).
+        sanitizers: result.taint.sanitizers ?? [],
         // cognium-ai#154 (L5c) — extract the CK + import/annotation fingerprint
         // while the IR is live so the top-level cluster pass in
         // `SecurityScanner.scan()` can consume it without re-invoking
@@ -142,6 +146,9 @@ coordinate) {
         // pre-2.33.0 cached entries will deserialize with `clusterVector`
         // undefined and be excluded from clustering on that scan.
         clusterVector: extractClusterVector(result),
+        // cognium-ai#330 — forward calls so enrichment sinks can be anchored in
+        // `runMerge` the same way discovery mode does in `DiscoveryEngine`.
+        calls: (result.calls ?? []),
     };
     // cognium-ai#153 — populate persistent tree cache. Disk-write errors
     // never fail the workflow. #158 Round 2 — coordinate is honored by
@@ -355,7 +362,17 @@ function findEnclosing(types, line) {
     }
     return {};
 }
-export function runMerge(patternSources, patternSinks, enrichmentResult, confidenceThreshold, sourceCode, filePath, types, language) {
+function methodLineBounds(types, line) {
+    const { type, method } = findEnclosing(types, line);
+    if (method) {
+        return { start: method.start_line, end: method.end_line };
+    }
+    if (type) {
+        return { start: type.start_line, end: type.end_line };
+    }
+    return undefined;
+}
+export function runMerge(patternSources, patternSinks, enrichmentResult, confidenceThreshold, sourceCode, filePath, types, language, irCalls) {
     // #48: previously these maps were keyed by `line` alone, which
     // collapsed any two sources / sinks that landed on the same source
     // line — even when they had different types or different variables.
@@ -432,34 +449,43 @@ export function runMerge(patternSources, patternSinks, enrichmentResult, confide
     }
     if (enrichmentResult) {
         for (const llmSink of enrichmentResult.additionalSinks) {
-            const key = sinkKey(llmSink);
-            const existing = sinksByKey.get(key);
+            const llmSinkCode = sliceLine(sourceCode, llmSink.line);
+            let sinkLine = llmSink.line;
+            let anchor;
+            const bounds = methodLineBounds(types, llmSink.line);
+            if (irCalls && bounds) {
+                const snippet = llmSinkCode && llmSinkCode.trim().length > 0
+                    ? llmSinkCode
+                    : llmSink.method
+                        ? `${llmSink.method}(`
+                        : '';
+                const resolved = resolveDiscoveryAnchor(llmSink.line, patternSinks, irCalls, bounds.start, bounds.end, llmSink.type, snippet);
+                sinkLine = resolved.line;
+                if (resolved.anchor !== 'ir-sink') {
+                    anchor = resolved.anchor;
+                }
+            }
+            const anchoredKey = sinkKey({ line: sinkLine, type: llmSink.type });
+            const existing = sinksByKey.get(anchoredKey);
             if (existing) {
-                sinksByKey.set(key, {
+                sinksByKey.set(anchoredKey, {
                     ...existing,
                     confidence: Math.min(1.0, (existing.confidence || 0.8) + 0.2),
                 });
             }
             else if (llmSink.confidence >= confidenceThreshold) {
-                // #90/#91/#92/#93/#94: previously LLM-discovered sinks omitted
-                // the `code` field entirely. Downstream `isSuppressedSinkShape`
-                // safely returns false on undefined → phantom-line findings
-                // leak through to the report. Look up the source line so the
-                // existing sink-shape filters (and the new phantom-line guard)
-                // can do their job.
-                const llmSinkCode = sliceLine(sourceCode, llmSink.line);
-                sinksByKey.set(key, {
-                    line: llmSink.line,
+                sinksByKey.set(anchoredKey, {
+                    line: sinkLine,
                     type: llmSink.type,
                     cwe: llmSink.cwe,
-                    location: `LLM-discovered at line ${llmSink.line}`,
+                    location: `LLM-discovered at line ${sinkLine}`,
                     confidence: llmSink.confidence,
                     method: llmSink.method,
                     argPositions: llmSink.argPositions,
-                    code: llmSinkCode,
+                    code: sliceLine(sourceCode, sinkLine) ?? llmSinkCode,
                     file: filePath,
-                    // #26: pure-LLM-discovered sink — see source-side comment above.
                     discoveryMethod: 'llm',
+                    ...(anchor ? { anchor } : {}),
                 });
             }
         }
@@ -562,6 +588,8 @@ contextProfile) {
             pairsDroppedByBudget: 0,
             pairsFailed: 0,
             unverifiedPairs: [],
+            // cognium-ai#471 — nothing was sent to the verifier.
+            submittedPairs: [],
             verificationError: undefined,
             processingTimeMs: 0,
         };
@@ -691,6 +719,13 @@ contextProfile) {
                 ? (batchResult.unverified_pairs ?? []).map((p) => ({ sourceLine: p.source_line, sinkLine: p.sink_line }))
                 : [],
             verificationError: batchResult.status === 'error' ? (batchResult.error ?? 'verification_chunk_failed') : undefined,
+            // cognium-ai#471 — the (source, sink) pairs this file put to the
+            // verifier. The batch prompt has the model OMIT every non-TRUE_POSITIVE
+            // pair, so a submitted pair that comes back absent from a successful
+            // chunk is the verifier's refutation. runReport needs the set to tell
+            // "refuted by omission" from "never asked" (sampling) when it labels the
+            // static findings it keeps.
+            submittedPairs: limitedSources.flatMap((s) => limitedSinks.map((k) => ({ sourceLine: s.line, sinkLine: k.line }))),
             processingTimeMs: batchResult.processingTimeMs,
         };
     }
@@ -714,6 +749,7 @@ contextProfile) {
             pairsDroppedByBudget: 0,
             pairsFailed: unverifiedPairs.length,
             unverifiedPairs,
+            submittedPairs: [], // #471 — nothing was answered
             verificationError: (error instanceof Error ? error.message : String(error)) || 'verification_failed',
             processingTimeMs: Date.now() - startTime,
         };
@@ -752,7 +788,19 @@ sourceCode,
  * much the verifier was asked about. Optional: legacy callers (tests) omit
  * it and the stats fall back to the returned counts.
  */
-verifyAccounting) {
+verifyAccounting, 
+/**
+ * cognium-ai#460 — the rest of `generateFindings`' argument list. With
+ * only (sources, sinks, dfg, file) every precision gate is off: the
+ * non-executable-line gate (needs `sourceCode` + `language`), sanitizer
+ * credit, and the method-scoped proximity gate (`types`). The static
+ * scanner passes all of them; this makes the detector index — and so the
+ * #264 verify-parity gate — use the same gates. (`flows` is not forwarded:
+ * it would turn on cognium-dev#372 flow emission, an additive change.) Optional: legacy
+ * callers (tests) omit it and keep the pre-#460 behaviour, except that
+ * `types` / `sourceCode` (already parameters) are now forwarded too.
+ */
+taintContext) {
     const vulnerabilities = [];
     // cognium-ai#264 Defect 1 — detector candidate index for verify-path parity.
     // `generateFindings()` applies `canSourceReachSink` (type coverage) + the
@@ -766,7 +814,7 @@ verifyAccounting) {
     // gap #258 left open (path_traversal's ceiling is `high`, so the rule cap alone
     // still reads C+H). Computed once and shared with the no-verification branch.
     const effectiveDfg = dfg ?? { defs: [], uses: [], chains: [] };
-    const detectorFindings = generateFindings(mergedSources, mergedSinks, effectiveDfg, filePath);
+    const detectorFindings = generateFindings(mergedSources, mergedSinks, effectiveDfg, filePath, sourceCode, taintContext?.language, taintContext?.sanitizers ?? [], (types ?? []));
     const detectorSevRank = { critical: 4, high: 3, medium: 2, low: 1 };
     const detectorSinkSeverity = new Map();
     for (const df of detectorFindings) {
@@ -1033,6 +1081,32 @@ verifyAccounting) {
         const srcs = finding.evidence?.sources ?? [{ line: finding.source.line }];
         return srcs.some((s) => failedPairKeys.has(`${s.line}:${finding.sink.line}`));
     };
+    // cognium-ai#471 — a static finding the verifier was asked about and did not
+    // confirm. The batch prompt has the model OMIT every non-TRUE_POSITIVE pair
+    // ("an omitted pair is counted as assessed-and-safe"), so when a file's
+    // verifier answer contains no TRUE_POSITIVE this branch used to keep every
+    // static finding as `UNVERIFIED` — the verifier's refutation was relabelled
+    // "no verdict", which circle-pack maps to `llm_result.verdict: UNCERTAIN`.
+    // That is how 81,842 skill-scan findings produced 0 FALSE_POSITIVE.
+    //
+    // A finding is refuted by omission only when the answer is unambiguous:
+    //   - the caller passed the submitted-pair set (legacy callers: no change);
+    //   - no pair was dropped by our fan-out budget, and none of the pairs the
+    //     model returned failed to map (a hallucinated line could be a TP we
+    //     cannot place);
+    //   - every contributing (source, sink) pair was submitted (a pair the
+    //     sampler never sent was never asked about);
+    //   - no contributing pair sits in a failed chunk (#564 keeps those open).
+    const submittedPairKeys = new Set((verifyAccounting?.submittedPairs ?? []).map((p) => `${p.sourceLine}:${p.sinkLine}`));
+    const omissionIsRefutation = submittedPairKeys.size > 0 &&
+        (verifyAccounting?.pairsDroppedByBudget ?? 0) === 0 &&
+        (verifyAccounting?.pairsUnmapped ?? 0) === 0;
+    const refutedByOmission = (finding) => {
+        if (!omissionIsRefutation || hitsFailedPair(finding))
+            return false;
+        const srcs = finding.evidence?.sources ?? [{ line: finding.source.line }];
+        return srcs.length > 0 && srcs.every((s) => submittedPairKeys.has(`${s.line}:${finding.sink.line}`));
+    };
     const verifiedBranch = verificationEnabled && verificationResults.length > 0;
     const verifiedLocs = new Set(vulnerabilities.map((v) => `${v.sink?.line}:${v.type}`));
     if (!verifiedBranch || failedPairKeys.size > 0) {
@@ -1151,7 +1225,25 @@ verifyAccounting) {
                             mode: 'attempted',
                             verification_error: verificationError ?? 'verification_chunk_failed',
                         }
-                        : { verdict: 'UNVERIFIED', attempted: true, llm_verified: false, mode: 'attempted' }, // #331 three-state
+                        : refutedByOmission(finding)
+                            ? {
+                                // cognium-ai#471 — the verifier answered, and its answer
+                                // (per the batch prompt's omit-non-TP contract) is "not a
+                                // true positive". Kept, not dropped: dropping would change
+                                // recall on every LLM scan, which is a product decision;
+                                // labelling it lets consumers see the refutation.
+                                verdict: 'FALSE_POSITIVE',
+                                attempted: true,
+                                llm_verified: false,
+                                mode: 'llm',
+                                refuted_by: 'omission',
+                                reasoning_source: 'template',
+                                reasoning: 'Submitted to the LLM verifier, which did not confirm it: the batch verifier ' +
+                                    'omits every pair it does not judge a TRUE_POSITIVE (cognium-ai#471).',
+                                confidence: 0,
+                                exploitability: 'none',
+                            }
+                            : { verdict: 'UNVERIFIED', attempted: true, llm_verified: false, mode: 'attempted' }, // #331 three-state
                 // #26: surface the provenance label so downstream consumers
                 // (cognium-ai CLI output, SARIF emitter) can distinguish
                 // static-only / LLM-only / mixed findings without re-deriving.
@@ -1177,6 +1269,9 @@ verifyAccounting) {
             // cognium-ai#564 — failed-chunk pairs, and the findings kept for them.
             pairsFailed: verifyAccounting?.pairsFailed ?? 0,
             findingsUnverified: vulnerabilities.filter((v) => v.verification?.verification_error !== undefined).length,
+            // cognium-ai#471 — findings kept with `verdict: 'FALSE_POSITIVE'`
+            // because the verifier omitted (refuted) every pair behind them.
+            findingsRefutedByOmission: vulnerabilities.filter((v) => v.verification?.refuted_by === 'omission').length,
             ...(verificationError !== undefined ? { verificationError } : {}),
             totalTimeMs: patternMatchTimeMs + enrichTimeMs + verifyTimeMs,
         },
@@ -1255,7 +1350,7 @@ export async function analyzeFile(filePath, sourceCode, options) {
         enrichResult = await runEnrich(filePath, sourceCode, patternResult.types, patternResult.imports, patternResult.patternSources, patternResult.patternSinks, enableEnrichment, language, llmConfig);
     }
     const mergeResult = runMerge(patternResult.patternSources, patternResult.patternSinks, enrichResult.enrichmentResult, confidenceThreshold, sourceCode, filePath, patternResult.types, // cognium-ai#128 gate
-    language);
+    language, patternResult.calls);
     // L2 — same pattern as enrich: wrap when the operator has opted in
     // via CP_VERIFY_TIMEOUT_MS.
     let verifyResult;
@@ -1278,7 +1373,10 @@ export async function analyzeFile(filePath, sourceCode, options) {
         pairsFailed: verifyResult.pairsFailed,
         unverifiedPairs: verifyResult.unverifiedPairs,
         verificationError: verifyResult.verificationError,
-    });
+        submittedPairs: verifyResult.submittedPairs, // cognium-ai#471
+    }, 
+    // cognium-ai#460 — full generateFindings argument list.
+    { language, sanitizers: patternResult.sanitizers });
     // cognium-ai#154 (L5c) — surface the cluster vector extracted while the
     // IR was live in `runPatternMatch`. Keeps `runReport`'s signature
     // untouched (its job is source×sink → vuln synthesis; the vector is
@@ -1313,7 +1411,7 @@ export async function* analyzeFileStream(filePath, sourceCode, options) {
     yield { step: 'enrich', status: 'completed', data: enrichResult };
     yield { step: 'merge', status: 'running' };
     const mergeResult = runMerge(patternResult.patternSources, patternResult.patternSinks, enrichResult.enrichmentResult, 0.7, sourceCode, filePath, patternResult.types, // cognium-ai#128 gate
-    language);
+    language, patternResult.calls);
     yield { step: 'merge', status: 'completed', data: mergeResult };
     yield { step: 'verify', status: 'running' };
     const verifyResult = await runVerify(filePath, sourceCode, mergeResult.mergedSources, mergeResult.mergedSinks, patternResult.types, enableVerification, maxVerificationTargets, verificationStrategy, llmConfig, language, contextProfile);
@@ -1331,7 +1429,10 @@ export async function* analyzeFileStream(filePath, sourceCode, options) {
         pairsFailed: verifyResult.pairsFailed,
         unverifiedPairs: verifyResult.unverifiedPairs,
         verificationError: verifyResult.verificationError,
-    });
+        submittedPairs: verifyResult.submittedPairs, // cognium-ai#471
+    }, 
+    // cognium-ai#460 — full generateFindings argument list.
+    { language, sanitizers: patternResult.sanitizers });
     yield { step: 'report', status: 'completed', data: reportResult };
 }
 // Legacy export for compatibility