Add 300 CheckerBench tasks, dataset card, and restoration tools (part 6)

tasks/csa159/pair_163861/task_prompt.md

@@ -0,0 +1,377 @@
+# Task: Synthesize a CSA Checker from a CVE Patch
+
+## Your Role
+
+You are a static analysis expert. Synthesize a Clang Static Analyzer (CSA) checker
+that detects the bug pattern fixed by the CVE patch in this working directory.
+
+You have full filesystem and bash access — use them.
+
+### Skills
+
+Many skills are available under `.claude/skills/` — covering vulnerability analysis,
+checker design, debugging, code audit, security patterns, and more.  Each skill
+encodes reusable expertise: take time to explore them, read their SKILL.md files,
+and invoke those that look useful via the Skill tool.  Let the task guide which
+ones you reach for.
+
+## File Layout
+
+```
+/work/
+├── compile.sh               ← RUN ME: compile checker.cpp → checker.so
+├── checker_template.cpp     ← skeleton, start here
+├── patch.diff               ← the CVE fix
+├── pre_functions.txt        ← buggy source (before_commit)
+├── post_functions.txt       ← patched source (after_commit)
+├── config.json              ← paths, commit_message, commit hashes, flags
+├── scan/
+│   ├── scan_before.sh       ← RUN ME: scan before_commit → N_buggy
+│   ├── scan_after.sh        ← RUN ME: scan after_commit → N_patched
+│   └── flags_*.txt          ← pre-extracted compile flags (-I, -D)
+├── references/
+│   ├── repo_knowledge.md            ← project-specific API/convention reference
+│   ├── patterns_summary.md       ← (optional) historical bug pattern summary
+│   ├── cwe_cards/                ← CWE knowledge library (all categories)
+│   │   ├── index.json             ← lookup index — use to find relevant cards
+│   │   ├── CWE-{id}(-variant).md  ← Tier 1/2 per-CWE detection patterns
+│   │   ├── Category-{name}.md     ← Tier 3 umbrella cards (rare CWEs grouped)
+│   ├── csa_headers_api.md   ← API quick reference (extracted from LLVM 18 headers)
+│   ├── csa_checker_patterns.md ← pattern catalog (resource tracking, null check, etc.)
+│   ├── csa_utility_functions.h ← copy-paste C++ helpers for checker.cpp (AST traversal, expression eval, etc.)
+│   └── examples/
+│       └── llvm-official/   ← 5 official checker sources (with comments)
+│           ├── 01_div_zero.cpp
+│           ├── 02_simple_stream.cpp
+│           ├── 03_undef_result.cpp
+│           ├── 04_nullability.cpp
+│           └── 05_malloc.cpp
+│
+├── checker.cpp              ← YOUR OUTPUT: synthesized checker
+├── checker.so               ← YOUR OUTPUT: compiled checker
+├── state.json               ← YOUR OUTPUT: structured task state
+├── scope_statement.md       ← YOUR OUTPUT: checker scope analysis (Level 1/2/3)
+└── summary.json             ← YOUR OUTPUT: final report
+```
+
+## Resources
+
+**Read these before writing any code:**
+
+1. **`references/csa_headers_api.md`** — CSA API quick reference. Extracted directly from
+   LLVM 18 headers. Covers all checker callbacks, ProgramState operations, SVal types,
+   MemRegion hierarchy, and bug reporting. **Read this first whenever you need API info.**
+
+2. **`references/csa_checker_patterns.md`** — Pattern catalog. Documents 5 battle-tested
+   patterns from official LLVM checkers: resource tracking, null checking, undefined
+   value detection, division-by-zero, and malloc/free. Each pattern includes skeleton
+   code, state traits, and key API usage.
+
+3. **`references/examples/llvm-official/`** — 5 official LLVM 18 checker implementations
+   with explanatory comments:
+   - `01_div_zero.cpp` — simplest checker (169 lines, 1 callback)
+   - `02_simple_stream.cpp` — resource tracking (292 lines, fopen/fclose)
+   - `03_undef_result.cpp` — PostStmt pattern (160 lines)
+   - `04_nullability.cpp` — multi-callback checker (1247 lines)
+   - `05_malloc.cpp` — comprehensive malloc/free (1511 lines)
+
+4. **`checker_template.cpp`** — Skeleton with placeholders. Start here.
+
+5. **`references/repo_knowledge.md`** — Project-specific reference. Contains this
+   repository's memory allocation API, key data types, source layout, and typical
+   CVE patterns. **Read this before writing the checker** — knowing the project's
+   alloc/free conventions and common bug patterns saves many grep rounds.
+
+5b. **`references/patterns_summary.md`** — (may not exist) Historical synthesis
+   patterns for this project.  If present, it contains a concise summary of the
+   most common bug patterns, frequent CWE categories, and reusable checker
+   architectures observed in previous synthesis runs.  Read after repo_knowledge.md.
+
+6. **`references/cwe_cards/`** — Complete CWE knowledge base covering all
+   vulnerability categories.  **The framework provides the full library —
+   you must identify the vulnerability type yourself.**  Workflow:
+
+   1. Analyse the patch diff and commit message to determine the vulnerability
+      type (buffer overflow, UAF, null deref, integer overflow, race condition,
+      etc.).  Do NOT rely on the CWE label — treat it as a hint at most.
+   2. Open ``index.json`` to discover available cards and their tiers.
+   3. Read the relevant card(s) for **detection strategies**, **checker
+      architecture suggestions**, and **known false-positive patterns**.
+
+   Card tiers:
+   - ``CWE-{id}(-{variant}).md`` — Tier 1/2 cards for common CWEs; kernel /
+     userspace variants when the detection strategy differs substantially.
+   - ``Category-{name}.md`` — Tier 3 umbrella cards grouping rarer CWEs by
+     category (input validation, resource management, etc.).
+
+7. **`references/csa_utility_functions.h`** — Copy-paste C++ helper functions for
+   checker.cpp. Includes AST traversal (`findSpecificTypeInParents/Children`),
+   expression evaluation (`EvaluateExprToInt`, `inferSymbolMaxVal`), array/string
+   size extraction, MemRegion helpers, and `ExprHasName()` for robust function
+   matching. All verified against LLVM 18. **Read before implementing detection
+   logic** — these save writing boilerplate that's easy to get wrong.
+
+## Environment
+
+Key paths are in ``config.json``.
+
+### Pre-built scripts
+
+| Script | What it does |
+|--------|-------------|
+| `bash compile.sh` | Compile checker.cpp → checker.so (with correct flags) |
+| `CHECKER_NAME=<name> bash scan/scan_before.sh` | Scan before_commit, count warnings → N_buggy |
+| `CHECKER_NAME=<name> bash scan/scan_after.sh` | Scan after_commit, count warnings → N_patched |
+
+```bash
+# Compile (run from workdir root)
+bash compile.sh
+
+# Scan — set CHECKER_NAME to the string passed to addChecker<>()
+CHECKER_NAME=your.CheckerName bash scan/scan_before.sh   # → N_buggy
+CHECKER_NAME=your.CheckerName bash scan/scan_after.sh    # → N_patched
+```
+
+- ``compile.sh`` already has the correct ``-I`` / ``-fno-rtti`` flags.
+- ``scan/scan_*.sh`` count only warnings tagged with your checker name.
+- Scan environments (source files + compile flags) are pre-built in ``scan/``.
+
+### Scan Script Integrity (CRITICAL)
+
+The scan scripts (``scan/scan_before.sh``, ``scan/scan_after.sh``) are the **only
+valid measurement** of N_buggy and N_patched.  They are the ground truth that the
+Python-side validator will also use.  You MUST obey these rules:
+
+**1. Never bypass the scan scripts.**  Do NOT run ``clang --analyze`` directly
+   to measure warning counts.  The Python validator runs the same scan scripts
+   — if you measured with a different command, your numbers will not reproduce
+   and the synthesis will be rejected.
+
+**2. If the scan script prints COMPILE_ERROR** (missing headers, undeclared
+   identifiers, etc.), the scan environment needs repair.  You MUST fix it:
+   - Add missing ``-I`` include paths to the flags files in ``scan/``
+   - Copy needed generated headers (e.g. ``autoconf.h``) from the snapshot
+   - If the file fundamentally cannot be compiled by clang, stop and write
+     ``summary.json`` with ``status: "failed"`` and an honest ``failure_reason``
+
+**3. Only trust scan script output.**  The ``Total <name> warnings: N`` line
+   printed by the scan script is the number that goes into ``summary.json``.
+   If the scan script says 0, write 0.  Fabricating numbers that the scan
+   script did not produce will cause the Python validator to reject the
+   synthesis.
+
+- If compile fails: read the error, fix ``checker.cpp``, retry (max 3 cycles).
+- If validation fails: revise checker logic, re-compile, re-scan.
+
+## MCP Tools
+
+You have access to 3 MCP tools under the `csa-tools` server (prefixed `mcp__csa-tools__`).
+Each returns **source context embedded in the result** — no need to follow up with Read.
+
+| Tool | What it does | Key advantage |
+|------|-------------|---------------|
+| `search(pattern, scope)` | Search for a pattern in source / LLVM headers / workdir | Returns file:line + 3 lines context — grep + Read in one call |
+| `compile()` | Run compile.sh, return parsed diagnostics | Errors include checker.cpp context — fix without reading the file |
+| `scan(checker_name)` | Run before/after scan, return N_buggy + N_patched + warning locations | Each warning includes source context — no manual clang --analyze needed |
+
+### When to use each
+
+- **`search`**: Whenever you would type `grep -rn "X"` or `find ... -name`. Use `scope="source"` for CVE code, `scope="llvm"` for CSA API headers, `scope="all"` when unsure.
+- **`compile`**: Instead of `bash compile.sh` followed by reading checker.cpp at error lines.
+- **`scan`**: Instead of running scan_before.sh + scan_after.sh + manual clang inspection. Returns everything you need to decide next action.
+
+## Semantic Design Contract — before writing checker.cpp
+
+Create the analysis portions of `state.json` and `scope_statement.md` **before**
+writing checker.cpp. They are a design contract, not a retrospective summary.
+After compilation, update only implementation facts such as `build_attempts`.
+
+In `patch_analysis`, distinguish the vulnerable operation, its trigger, and the
+semantic fact introduced by the patch that makes it safe. In `detection_plan`,
+make `report_condition`, `safe_condition`, and `source_level_signal` concrete
+CSA-observable facts. In `api_choice`, record the mechanism level and explain
+why the selected callback can observe and prove those facts.
+
+In `scope_statement.md`, include this mapping table and check it again after
+implementation:
+
+| Semantic condition | CSA evidence | checker.cpp implementation |
+| --- | --- | --- |
+| report condition | AST / SVal / MemRegion / CFG evidence | callback, helper, and branch that reports |
+| safe condition | path constraint, guard, state discharge, or structural fact | branch that suppresses the report |
+
+Every condition in the plan must have an implementation entry. Do not claim a
+condition that checker.cpp does not implement, and do not silently add a code
+condition absent from the plan.
+
+## Mechanism Selection — diagnose before coding
+
+Choose the weakest CSA mechanism that can prove the vulnerability property:
+
+1. **syntax-only AST**: only when local AST shape itself is the defect;
+2. **control flow / dominance**: when guard placement relative to a sink matters;
+3. **path-sensitive ProgramState/SVal**: when an unsafe state must reach a use;
+4. **cross-procedure/dataflow**: when the required fact crosses function boundaries.
+
+For a guard-based patch, prove both that the guard rejects the unsafe value and
+that it dominates the vulnerable use. For path-sensitive or cross-procedure
+defects, do not replace the required state or flow proof with local AST matching
+or source-text substring matching merely because it passes the differential scan.
+Record the selected level as `api_choice.mechanism_level`.
+
+## Semantic identity, locality, and final validation
+
+Before accepting the checker, verify that its primary matching logic does not
+depend on patch-local variable names, labels, line numbers, commit IDs, or unique
+literals. Project APIs, types, and stable semantic call relationships are valid
+scope anchors when they define the vulnerability class. Attach the report to the
+actual vulnerable operation, and implement every suppression as a real safe
+condition rather than the mere presence of a nearby guard-shaped statement.
+
+The required final sequence is: **compile → before scan → after scan → inspect
+the final checker name, artifacts, and report locations → write summary.json**.
+Always run the final compile and both scans. `MAX_IN_SESSION_REDESIGNS` limits only
+additional redesign cycles after a failed validation; if it is zero, preserve the
+real validation evidence and report failure honestly rather than fabricating counts.
+
+## Validation Criteria
+
+```
+VALID   : N_buggy > N_patched  AND  N_patched < 50
+INVALID : otherwise → revise and re-validate (max 1 attempts)
+```
+
+## Refinement
+
+Do NOT self-refine the checker repeatedly. Your goal is to produce the first
+checker that passes the Validation Criteria above — fix compile errors and
+validation failures only. False positives are triaged and repaired by the
+framework's refinement stage: you will receive a concrete FP list via
+session resume (if needed) and fix only those. Reserve budget for that stage.
+
+## Output
+
+Produce all of the following **only when completely done**:
+
+| File | Content |
+|------|---------|
+| ``checker.cpp`` | Synthesized checker source code |
+| ``checker.so`` | Compiled checker plugin |
+| ``state.json`` | Structured task state (see schema below) |
+| ``scope_statement.md`` | Checker scope analysis in prose (Level 1/2/3) |
+| ``summary.json`` | Final report (see schema below) |
+
+Writing ``summary.json`` signals completion.  Do NOT write it early.
+
+### ``state.json``
+
+Create this before writing checker.cpp to capture the design contract. After the
+checker compiles, update only implementation facts and retain the original
+semantic plan.
+
+```json
+{
+  "patch_analysis": {
+    "summary":           "One sentence describing the vulnerability this patch fixes",
+    "changed_files":     ["file1.c", "file2.h"],
+    "changed_functions": ["func_a", "func_b"],
+    "bug_type":          "buffer_overflow | use_after_free | null_deref | integer_overflow | race_condition | resource_leak | double_free | input_validation | other",
+    "fix_strategy":      "add_bounds_check | add_null_check | add_size_check | add_early_return | reorder_operations | change_api_signature | other",
+    "affected_types":    ["GF_BitStream", "custom_struct_t"],
+    "critical_calls":    ["gf_strdup", "memcpy"]
+  },
+  "detection_plan": {
+    "bug_pattern":         "High-level description of the vulnerability pattern (e.g. 'heap buffer overflow when reading variable-length data into a fixed-size stack buffer without size bound')",
+    "report_condition":    "When should the checker emit a warning? (e.g. 'call to gf_strdup where the argument originates from a fixed-size local array that was populated by variable-length bitstream reads')",
+    "safe_condition":      "When should the checker NOT emit a warning? (e.g. 'argument originates from a heap allocation or a size-bounded source')",
+    "source_level_signal": "What AST / MemRegion / SVal property does the checker look for? (e.g. 'MemRegion extent < parameter size at a PreCall to gf_strdup')"
+  },
+  "api_choice": {
+    "mechanism_level":          "syntactic_ast | control_flow | path_sensitive | interprocedural_dataflow",
+    "callback":                 "check::PreCall | check::PostCall | check::PreStmt | check::PostStmt | check::Bind | check::DeadSymbols | check::EndFunction | ...",
+    "reasoning":                "Why this callback and its AST/state/CFG evidence prove the report and safe conditions",
+    "alternatives_considered":  ["check::PostCall"]
+  },
+  "implementation": {
+    "scope_level":    "patch_specific | project_general | cross_project",
+    "checker_name":   "project.CheckerName",
+    "build_attempts": 1
+  }
+}
+```
+
+### ``summary.json``
+
+```json
+{
+  "status":           "plausible | failed",
+  "bug_pattern":      "One sentence describing the bug pattern",
+  "scope_level":      "patch_specific | project_general | cross_project",
+  "checker_cpp":      "checker.cpp",
+  "checker_so":       "checker.so",
+  "n_buggy":          0,
+  "n_patched":        0,
+  "total_reports":    0,
+  "fp_rate_estimate": 0.0,
+  "failure_reason":   null
+}
+```
+
+## Feedback-derived requirements for this fresh synthesis
+
+A prior independent rollout exposed the risks below. Start again from the patch
+in this new session. Do not reconstruct, edit, or assume the prior checker.
+
+Required mechanism level: `interprocedural_dataflow`
+
+### Current failure diagnosis
+
+- The failed rollout used a syntax-only AST pattern and therefore did not establish the cross-function failure condition: an allocation failure in the xa_store path can leave xarray metadata indicating non-empty while no entry is enumerable.
+- Matching every direct callee whose name ends in _empty treated unrelated list, queue, and project-specific predicates as if they shared xa_empty's failure semantics.
+- Odd negation parity inside a WARN/BUG expansion proves only expression shape; it does not prove that the affected xarray state can feasibly reach the teardown assertion.
+- Refinement remained feedback_required, the semantic mechanism was rated inadequate, and the semantic score stayed below threshold despite successful differential detection.
+
+### Preserve from prior rollouts
+
+- Preserve successful compile, before/after validation, and code verification.
+- Preserve objective eligibility gate G6.
+- Preserve process quality at or above the configured threshold.
+- Do not introduce patch-anchor dependence.
+- Do not introduce patch-local hardcoding.
+
+### Required semantic proof
+
+- Establish that a feasible allocation-error or partial-completion path associated with xa_store can produce an xarray whose head metadata is non-NULL while no actual entry is enumerable.
+- Establish that this exceptional xarray fact propagates across the relevant function boundaries to the same abstract xarray object inspected during teardown.
+- Establish that xa_empty on that object can evaluate false because it observes head metadata, and that its negated result controls a reachable WARN_ON_ONCE trap path.
+- Distinguish the vulnerable metadata-based assertion from the patched behavior, where xa_for_each reaches the warning only after observing an actual entry.
+
+### Implementation constraints
+
+- Use CSA interprocedural analysis with ProgramState facts or equivalent call summaries for the exceptional xa_store outcome and preserve object identity for the affected xarray region across calls.
+- Use call-event callbacks suitable for modeling xa_store and xa_empty, and combine them with CFG or branch-condition evidence that the xa_empty result controls the macro-expanded trap path.
+- Inspect the post-preprocessing assertion structure because WARN_ON_ONCE is not a callable sink; recognize its reachable __bug_table trap through AST/CFG relationships rather than a WARN_ON_ONCE call event.
+- Emit a report only when the exceptional xa_store-derived fact, the same xarray region, the false xa_empty result, and the reachable trap branch are all related.
+- Attach the diagnostic to the vulnerable xa_empty use in the assertion and keep the report within the function containing that use.
+- Scope modeling to evidenced xarray semantics; do not infer equivalent behavior from generic *_empty naming conventions.
+- Use stable API or semantic identities for xarray operations and regions, without file paths, line numbers, local variable names, commit identifiers, or changed-line anchors.
+
+### Validation checklist
+
+- Compile the new checker successfully against the target Clang Static Analyzer API and verify checker registration and loading.
+- Scan both supplied pre-patch inputs and confirm the expected diagnostics occur at the xa_empty call in __io_uring_free.
+- Scan both supplied post-patch inputs and confirm zero diagnostics after replacement with xa_for_each.
+- Verify each pre-patch report is on the changed assertion line with no duplicate report for the same semantic path.
+- Add or run a relevant case where a normal xa_store outcome reaches !xa_empty and confirm that the exceptional-state report is suppressed.
+- Add or run relevant negative cases for list_empty, skb_queue_empty, arbitrary *_empty functions, and negated emptiness tests outside trap assertions.
+- Confirm interprocedural propagation uses the same xarray region and does not report when the exceptional fact belongs to a different container.
+- Complete refinement with an accepted clean outcome while retaining G6, hard validation, code verification, and the configured process-score threshold.
+
+### Avoid and forbidden regressions
+
+- Do not reuse a syntax-only odd-negation plus trap-assembly pattern as sufficient evidence of the vulnerability.
+- Do not classify all functions ending in _empty, including list_empty_careful, as metadata-only predicates with xa_empty's partial-insertion behavior.
+- Do not report solely because !xa_empty appears inside a WARN_ON, WARN_ON_ONCE, WARN_ONCE, BUG, or BUG_ON expansion.
+- Do not rely on PreCall or PostCall to observe WARN_ON_ONCE itself, because preprocessing expands it into a statement expression and inline trap assembly.
+- Do not substitute generic warning proximity or before/after disappearance for proof of the failed-store state reaching the assertion.
+- Do not introduce source-text matching or patch-local file, function, variable, line, or commit anchors.

tasks/csa159/pair_163978/checker_template.cpp

@@ -0,0 +1,98 @@
+// ============================================================================
+// CSA Checker Template
+// ============================================================================
+// Fill in the sections marked with TODO to implement your checker.
+// The checker is compiled with -fno-rtti to match the LLVM 18 build config.
+// It is loaded via: clang -cc1 -load checker.so -analyzer-checker=your.CheckerName
+//
+// Compilation:
+//   clang++ -std=c++17 -fPIC -shared -fno-rtti -fno-exceptions \
+//           -I${LLVM_BUILD_DIR}/include \
+//           checker.cpp -o checker.so \
+//           -Wl,--allow-shlib-undefined
+//
+// Usage:
+//   clang -cc1 -load ./checker.so -analyzer-checker=your.CheckerName -analyze <file>
+// ============================================================================
+
+#include "clang/StaticAnalyzer/Core/BugReporter/BugReporter.h"
+#include "clang/StaticAnalyzer/Core/BugReporter/BugType.h"
+#include "clang/StaticAnalyzer/Core/Checker.h"
+#include "clang/StaticAnalyzer/Core/PathSensitive/CallEvent.h"
+#include "clang/StaticAnalyzer/Core/PathSensitive/CheckerContext.h"
+#include "clang/StaticAnalyzer/Frontend/CheckerRegistry.h"
+
+using namespace clang;
+using namespace ento;
+
+namespace {
+
+// ────────────────────────────────────────────────────────────────
+// TODO: Rename this class to describe your checker's purpose.
+// ────────────────────────────────────────────────────────────────
+class {{CHECKER_CLASS_NAME}}
+    : public Checker<check::PreCall,      // for checking before function calls
+                     check::PostCall>     // for checking after function calls
+{
+  // TODO: Customize the bug type name and category.
+  mutable std::unique_ptr<BugType> BT;
+
+public:
+  {{CHECKER_CLASS_NAME}}()
+      : BT(new BugType(this, "{{BUG_NAME}}", "{{BUG_CATEGORY}}")) {}
+
+  // ── PreCall callback (fires before every function call) ──────
+  void checkPreCall(const CallEvent &Call, CheckerContext &C) const {
+    // TODO: Implement your pre-call analysis logic here.
+    //
+    // Common patterns:
+    //
+    // 1. Check if the called function matches a specific name:
+    //    if (Call.getCalleeIdentifier()) {
+    //      StringRef name = Call.getCalleeIdentifier()->getName();
+    //      if (name == "target_function") { ... }
+    //    }
+    //
+    // 2. Get the program state:
+    //    ProgramStateRef State = C.getState();
+    //
+    // 3. Get arguments:
+    //    SVal Arg = Call.getArgSVal(0);
+    //
+    // 4. Generate a bug report:
+    //    ExplodedNode *ErrNode = C.generateErrorNode();
+    //    if (ErrNode) {
+    //      auto R = std::make_unique<PathSensitiveBugReport>(
+    //          *BT, "Description of the bug", ErrNode);
+    //      C.emitReport(std::move(R));
+    //    }
+  }
+
+  // ── PostCall callback (fires after every function call) ─────
+  void checkPostCall(const CallEvent &Call, CheckerContext &C) const {
+    // TODO: Implement your post-call analysis logic here.
+    //
+    // Common pattern — check the return value:
+    //   SVal RetVal = Call.getReturnValue();
+    //   if (RetVal.isUnknownOrUndef()) return;
+    //
+    //   ProgramStateRef State = C.getState();
+    //   // Modify state based on post-call conditions...
+  }
+};
+
+} // anonymous namespace
+
+// ────────────────────────────────────────────────────────────────
+// Registration — DO NOT modify the function signatures.
+// ────────────────────────────────────────────────────────────────
+
+extern "C" void clang_registerCheckers(CheckerRegistry &registry) {
+  registry.addChecker<{{CHECKER_CLASS_NAME}}>(
+      "{{CHECKER_FULL_NAME}}",  // e.g., "your.NullDereferenceChecker"
+      "{{CHECKER_DESC}}",       // e.g., "Detects null pointer dereference"
+      "{{CHECKER_DOC_URI}}");   // e.g., "https://example.com/docs"
+}
+
+extern "C" const char clang_analyzerAPIVersionString[] =
+    CLANG_ANALYZER_API_VERSION_STRING;

tasks/csa159/pair_163978/config.json

@@ -0,0 +1,19 @@
+{
+  "project_id": "torvalds_linux",
+  "before_commit": "504fa212d7030fb1c042290dc2eb92b21515573a",
+  "after_commit": "3bb2a01caa813d3a1845d378bbe4169ef280d394",
+  "repo_path": "/workspace/repo/torvalds/linux",
+  "llvm_build_dir": "/opt/llvm",
+  "before_compile_commands": "/workspace/benchmark/data-pipeline/snapshots/torvalds_linux/b7bfaa761d760e72a969d116517eaa12e404c262/compile_commands.json",
+  "after_compile_commands": "/workspace/benchmark/data-pipeline/snapshots/torvalds_linux/b7bfaa761d760e72a969d116517eaa12e404c262/compile_commands.json",
+  "changed_files": [
+    "lib/kobject.c"
+  ],
+  "commit_message": "kobject: Fix slab-out-of-bounds in fill_kobj_path()\n\nIn kobject_get_path(), if kobj->name is changed between calls\nget_kobj_path_length() and fill_kobj_path() and the length becomes\nlonger, then fill_kobj_path() will have an out-of-bounds bug.\n\nThe actual current problem occurs when the ixgbe probe.\n\nIn ixgbe_mii_bus_init(), if the length of netdev->dev.kobj.name\nlength becomes longer, out-of-bounds will occur.\n\ncpu0                                         cpu1\nixgbe_probe\n register_netdev(netdev)\n  netdev_register_kobject\n   device_add\n    kobject_uevent // Sending ADD events\n                                             systemd-udevd // rename netdev\n                                              dev_change_name\n                                               device_rename\n                                                kobject_rename\n ixgbe_mii_bus_init                             |\n  mdiobus_register                              |\n   __mdiobus_register                           |\n    device_register                             |\n     device_add                                 |\n      kobject_uevent                            |\n       kobject_get_path                         |\n        len = get_kobj_path_length // old name  |\n        path = kzalloc(len, gfp_mask);          |\n                                                kobj->name = name;\n                                                /* name length becomes\n                                                 * longer\n                                                 */\n        fill_kobj_path /* kobj path length is\n                        * longer than path,\n                        * resulting in out of\n                        * bounds when filling path\n                        */\n\nThis is the kasan report:\n\n==================================================================\nBUG: KASAN: slab-out-of-bounds in fill_kobj_path+0x50/0xc0\nWrite of size 7 at addr ff1100090573d1fd by task kworker/28:1/673\n\n Workqueue: events work_for_cpu_fn\n Call Trace:\n <TASK>\n dump_stack_lvl+0x34/0x48\n print_address_description.constprop.0+0x86/0x1e7\n print_report+0x36/0x4f\n kasan_report+0xad/0x130\n kasan_check_range+0x35/0x1c0\n memcpy+0x39/0x60\n fill_kobj_path+0x50/0xc0\n kobject_get_path+0x5a/0xc0\n kobject_uevent_env+0x140/0x460\n device_add+0x5c7/0x910\n __mdiobus_register+0x14e/0x490\n ixgbe_probe.cold+0x441/0x574 [ixgbe]\n local_pci_probe+0x78/0xc0\n work_for_cpu_fn+0x26/0x40\n process_one_work+0x3b6/0x6a0\n worker_thread+0x368/0x520\n kthread+0x165/0x1a0\n ret_from_fork+0x1f/0x30\n\nThis reproducer triggers that bug:\n\nwhile:\ndo\n    rmmod ixgbe\n    sleep 0.5\n    modprobe ixgbe\n    sleep 0.5\n\nWhen calling fill_kobj_path() to fill path, if the name length of\nkobj becomes longer, return failure and retry. This fixes the problem.\n\nFixes: 1da177e4c3f4 (\"Linux-2.6.12-rc2\")\nSigned-off-by: Wang Hai <wanghai38@huawei.com>\nLink: https://lore.kernel.org/r/20221220012143.52141-1-wanghai38@huawei.com\nSigned-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>",
+  "t_valid": 50,
+  "t_plausible": 20,
+  "triage_sample_size": 10,
+  "max_synthesis_retry": 0,
+  "max_in_session_redesigns": 1,
+  "max_refinement_iter": 3
+}

tasks/csa159/pair_163978/patch.diff

@@ -0,0 +1,49 @@
+diff --git a/lib/kobject.c b/lib/kobject.c
+index 985ee1c4f2c6..d20ce15eec2d 100644
+--- a/lib/kobject.c
++++ b/lib/kobject.c
+@@ -112,7 +112,7 @@ static int get_kobj_path_length(const struct kobject *kobj)
+ 	return length;
+ }
+ 
+-static void fill_kobj_path(const struct kobject *kobj, char *path, int length)
++static int fill_kobj_path(const struct kobject *kobj, char *path, int length)
+ {
+ 	const struct kobject *parent;
+ 
+@@ -121,12 +121,16 @@ static void fill_kobj_path(const struct kobject *kobj, char *path, int length)
+ 		int cur = strlen(kobject_name(parent));
+ 		/* back up enough to print this name with '/' */
+ 		length -= cur;
++		if (length <= 0)
++			return -EINVAL;
+ 		memcpy(path + length, kobject_name(parent), cur);
+ 		*(path + --length) = '/';
+ 	}
+ 
+ 	pr_debug("kobject: '%s' (%p): %s: path = '%s'\n", kobject_name(kobj),
+ 		 kobj, __func__, path);
++
++	return 0;
+ }
+ 
+ /**
+@@ -141,13 +145,17 @@ char *kobject_get_path(const struct kobject *kobj, gfp_t gfp_mask)
+ 	char *path;
+ 	int len;
+ 
++retry:
+ 	len = get_kobj_path_length(kobj);
+ 	if (len == 0)
+ 		return NULL;
+ 	path = kzalloc(len, gfp_mask);
+ 	if (!path)
+ 		return NULL;
+-	fill_kobj_path(kobj, path, len);
++	if (fill_kobj_path(kobj, path, len)) {
++		kfree(path);
++		goto retry;
++	}
+ 
+ 	return path;
+ }

tasks/csa159/pair_163978/post_functions.txt

@@ -0,0 +1,61 @@
+### File: lib/kobject.c
+```c
+static int get_kobj_path_length(const struct kobject *kobj)
+{
+	int length = 1;
+	const struct kobject *parent = kobj;
+
+	/* walk up the ancestors until we hit the one pointing to the
+	 * root.
+	 * Add 1 to strlen for leading '/' of each level.
+	 */
+	do {
+		if (kobject_name(parent) == NULL)
+			return 0;
+		length += strlen(kobject_name(parent)) + 1;
+		parent = parent->parent;
+	} while (parent);
+	return length;
+}
+
+static int fill_kobj_path(const struct kobject *kobj, char *path, int length)
+{
+	const struct kobject *parent;
+
+	--length;
+	for (parent = kobj; parent; parent = parent->parent) {
+		int cur = strlen(kobject_name(parent));
+		/* back up enough to print this name with '/' */
+		length -= cur;
+		if (length <= 0)
+			return -EINVAL;
+		memcpy(path + length, kobject_name(parent), cur);
+		*(path + --length) = '/';
+	}
+
+	pr_debug("kobject: '%s' (%p): %s: path = '%s'\n", kobject_name(kobj),
+		 kobj, __func__, path);
+
+	return 0;
+}
+
+char *kobject_get_path(const struct kobject *kobj, gfp_t gfp_mask)
+{
+	char *path;
+	int len;
+
+retry:
+	len = get_kobj_path_length(kobj);
+	if (len == 0)
+		return NULL;
+	path = kzalloc(len, gfp_mask);
+	if (!path)
+		return NULL;
+	if (fill_kobj_path(kobj, path, len)) {
+		kfree(path);
+		goto retry;
+	}
+
+	return path;
+}
+```

tasks/csa159/pair_163978/pre_functions.txt

@@ -0,0 +1,53 @@
+### File: lib/kobject.c
+```c
+static int get_kobj_path_length(const struct kobject *kobj)
+{
+	int length = 1;
+	const struct kobject *parent = kobj;
+
+	/* walk up the ancestors until we hit the one pointing to the
+	 * root.
+	 * Add 1 to strlen for leading '/' of each level.
+	 */
+	do {
+		if (kobject_name(parent) == NULL)
+			return 0;
+		length += strlen(kobject_name(parent)) + 1;
+		parent = parent->parent;
+	} while (parent);
+	return length;
+}
+
+static void fill_kobj_path(const struct kobject *kobj, char *path, int length)
+{
+	const struct kobject *parent;
+
+	--length;
+	for (parent = kobj; parent; parent = parent->parent) {
+		int cur = strlen(kobject_name(parent));
+		/* back up enough to print this name with '/' */
+		length -= cur;
+		memcpy(path + length, kobject_name(parent), cur);
+		*(path + --length) = '/';
+	}
+
+	pr_debug("kobject: '%s' (%p): %s: path = '%s'\n", kobject_name(kobj),
+		 kobj, __func__, path);
+}
+
+char *kobject_get_path(const struct kobject *kobj, gfp_t gfp_mask)
+{
+	char *path;
+	int len;
+
+	len = get_kobj_path_length(kobj);
+	if (len == 0)
+		return NULL;
+	path = kzalloc(len, gfp_mask);
+	if (!path)
+		return NULL;
+	fill_kobj_path(kobj, path, len);
+
+	return path;
+}
+```

tasks/csa159/pair_163978/task_prompt.md

@@ -0,0 +1,381 @@
+# Task: Synthesize a CSA Checker from a CVE Patch
+
+## Your Role
+
+You are a static analysis expert. Synthesize a Clang Static Analyzer (CSA) checker
+that detects the bug pattern fixed by the CVE patch in this working directory.
+
+You have full filesystem and bash access — use them.
+
+### Skills
+
+Many skills are available under `.claude/skills/` — covering vulnerability analysis,
+checker design, debugging, code audit, security patterns, and more.  Each skill
+encodes reusable expertise: take time to explore them, read their SKILL.md files,
+and invoke those that look useful via the Skill tool.  Let the task guide which
+ones you reach for.
+
+## File Layout
+
+```
+/work/
+├── compile.sh               ← RUN ME: compile checker.cpp → checker.so
+├── checker_template.cpp     ← skeleton, start here
+├── patch.diff               ← the CVE fix
+├── pre_functions.txt        ← buggy source (before_commit)
+├── post_functions.txt       ← patched source (after_commit)
+├── config.json              ← paths, commit_message, commit hashes, flags
+├── scan/
+│   ├── scan_before.sh       ← RUN ME: scan before_commit → N_buggy
+│   ├── scan_after.sh        ← RUN ME: scan after_commit → N_patched
+│   └── flags_*.txt          ← pre-extracted compile flags (-I, -D)
+├── references/
+│   ├── repo_knowledge.md            ← project-specific API/convention reference
+│   ├── patterns_summary.md       ← (optional) historical bug pattern summary
+│   ├── cwe_cards/                ← CWE knowledge library (all categories)
+│   │   ├── index.json             ← lookup index — use to find relevant cards
+│   │   ├── CWE-{id}(-variant).md  ← Tier 1/2 per-CWE detection patterns
+│   │   ├── Category-{name}.md     ← Tier 3 umbrella cards (rare CWEs grouped)
+│   ├── csa_headers_api.md   ← API quick reference (extracted from LLVM 18 headers)
+│   ├── csa_checker_patterns.md ← pattern catalog (resource tracking, null check, etc.)
+│   ├── csa_utility_functions.h ← copy-paste C++ helpers for checker.cpp (AST traversal, expression eval, etc.)
+│   └── examples/
+│       └── llvm-official/   ← 5 official checker sources (with comments)
+│           ├── 01_div_zero.cpp
+│           ├── 02_simple_stream.cpp
+│           ├── 03_undef_result.cpp
+│           ├── 04_nullability.cpp
+│           └── 05_malloc.cpp
+│
+├── checker.cpp              ← YOUR OUTPUT: synthesized checker
+├── checker.so               ← YOUR OUTPUT: compiled checker
+├── state.json               ← YOUR OUTPUT: structured task state
+├── scope_statement.md       ← YOUR OUTPUT: checker scope analysis (Level 1/2/3)
+└── summary.json             ← YOUR OUTPUT: final report
+```
+
+## Resources
+
+**Read these before writing any code:**
+
+1. **`references/csa_headers_api.md`** — CSA API quick reference. Extracted directly from
+   LLVM 18 headers. Covers all checker callbacks, ProgramState operations, SVal types,
+   MemRegion hierarchy, and bug reporting. **Read this first whenever you need API info.**
+
+2. **`references/csa_checker_patterns.md`** — Pattern catalog. Documents 5 battle-tested
+   patterns from official LLVM checkers: resource tracking, null checking, undefined
+   value detection, division-by-zero, and malloc/free. Each pattern includes skeleton
+   code, state traits, and key API usage.
+
+3. **`references/examples/llvm-official/`** — 5 official LLVM 18 checker implementations
+   with explanatory comments:
+   - `01_div_zero.cpp` — simplest checker (169 lines, 1 callback)
+   - `02_simple_stream.cpp` — resource tracking (292 lines, fopen/fclose)
+   - `03_undef_result.cpp` — PostStmt pattern (160 lines)
+   - `04_nullability.cpp` — multi-callback checker (1247 lines)
+   - `05_malloc.cpp` — comprehensive malloc/free (1511 lines)
+
+4. **`checker_template.cpp`** — Skeleton with placeholders. Start here.
+
+5. **`references/repo_knowledge.md`** — Project-specific reference. Contains this
+   repository's memory allocation API, key data types, source layout, and typical
+   CVE patterns. **Read this before writing the checker** — knowing the project's
+   alloc/free conventions and common bug patterns saves many grep rounds.
+
+5b. **`references/patterns_summary.md`** — (may not exist) Historical synthesis
+   patterns for this project.  If present, it contains a concise summary of the
+   most common bug patterns, frequent CWE categories, and reusable checker
+   architectures observed in previous synthesis runs.  Read after repo_knowledge.md.
+
+6. **`references/cwe_cards/`** — Complete CWE knowledge base covering all
+   vulnerability categories.  **The framework provides the full library —
+   you must identify the vulnerability type yourself.**  Workflow:
+
+   1. Analyse the patch diff and commit message to determine the vulnerability
+      type (buffer overflow, UAF, null deref, integer overflow, race condition,
+      etc.).  Do NOT rely on the CWE label — treat it as a hint at most.
+   2. Open ``index.json`` to discover available cards and their tiers.
+   3. Read the relevant card(s) for **detection strategies**, **checker
+      architecture suggestions**, and **known false-positive patterns**.
+
+   Card tiers:
+   - ``CWE-{id}(-{variant}).md`` — Tier 1/2 cards for common CWEs; kernel /
+     userspace variants when the detection strategy differs substantially.
+   - ``Category-{name}.md`` — Tier 3 umbrella cards grouping rarer CWEs by
+     category (input validation, resource management, etc.).
+
+7. **`references/csa_utility_functions.h`** — Copy-paste C++ helper functions for
+   checker.cpp. Includes AST traversal (`findSpecificTypeInParents/Children`),
+   expression evaluation (`EvaluateExprToInt`, `inferSymbolMaxVal`), array/string
+   size extraction, MemRegion helpers, and `ExprHasName()` for robust function
+   matching. All verified against LLVM 18. **Read before implementing detection
+   logic** — these save writing boilerplate that's easy to get wrong.
+
+## Environment
+
+Key paths are in ``config.json``.
+
+### Pre-built scripts
+
+| Script | What it does |
+|--------|-------------|
+| `bash compile.sh` | Compile checker.cpp → checker.so (with correct flags) |
+| `CHECKER_NAME=<name> bash scan/scan_before.sh` | Scan before_commit, count warnings → N_buggy |
+| `CHECKER_NAME=<name> bash scan/scan_after.sh` | Scan after_commit, count warnings → N_patched |
+
+```bash
+# Compile (run from workdir root)
+bash compile.sh
+
+# Scan — set CHECKER_NAME to the string passed to addChecker<>()
+CHECKER_NAME=your.CheckerName bash scan/scan_before.sh   # → N_buggy
+CHECKER_NAME=your.CheckerName bash scan/scan_after.sh    # → N_patched
+```
+
+- ``compile.sh`` already has the correct ``-I`` / ``-fno-rtti`` flags.
+- ``scan/scan_*.sh`` count only warnings tagged with your checker name.
+- Scan environments (source files + compile flags) are pre-built in ``scan/``.
+
+### Scan Script Integrity (CRITICAL)
+
+The scan scripts (``scan/scan_before.sh``, ``scan/scan_after.sh``) are the **only
+valid measurement** of N_buggy and N_patched.  They are the ground truth that the
+Python-side validator will also use.  You MUST obey these rules:
+
+**1. Never bypass the scan scripts.**  Do NOT run ``clang --analyze`` directly
+   to measure warning counts.  The Python validator runs the same scan scripts
+   — if you measured with a different command, your numbers will not reproduce
+   and the synthesis will be rejected.
+
+**2. If the scan script prints COMPILE_ERROR** (missing headers, undeclared
+   identifiers, etc.), the scan environment needs repair.  You MUST fix it:
+   - Add missing ``-I`` include paths to the flags files in ``scan/``
+   - Copy needed generated headers (e.g. ``autoconf.h``) from the snapshot
+   - If the file fundamentally cannot be compiled by clang, stop and write
+     ``summary.json`` with ``status: "failed"`` and an honest ``failure_reason``
+
+**3. Only trust scan script output.**  The ``Total <name> warnings: N`` line
+   printed by the scan script is the number that goes into ``summary.json``.
+   If the scan script says 0, write 0.  Fabricating numbers that the scan
+   script did not produce will cause the Python validator to reject the
+   synthesis.
+
+- If compile fails: read the error, fix ``checker.cpp``, retry (max 3 cycles).
+- If validation fails: revise checker logic, re-compile, re-scan.
+
+## MCP Tools
+
+You have access to 3 MCP tools under the `csa-tools` server (prefixed `mcp__csa-tools__`).
+Each returns **source context embedded in the result** — no need to follow up with Read.
+
+| Tool | What it does | Key advantage |
+|------|-------------|---------------|
+| `search(pattern, scope)` | Search for a pattern in source / LLVM headers / workdir | Returns file:line + 3 lines context — grep + Read in one call |
+| `compile()` | Run compile.sh, return parsed diagnostics | Errors include checker.cpp context — fix without reading the file |
+| `scan(checker_name)` | Run before/after scan, return N_buggy + N_patched + warning locations | Each warning includes source context — no manual clang --analyze needed |
+
+### When to use each
+
+- **`search`**: Whenever you would type `grep -rn "X"` or `find ... -name`. Use `scope="source"` for CVE code, `scope="llvm"` for CSA API headers, `scope="all"` when unsure.
+- **`compile`**: Instead of `bash compile.sh` followed by reading checker.cpp at error lines.
+- **`scan`**: Instead of running scan_before.sh + scan_after.sh + manual clang inspection. Returns everything you need to decide next action.
+
+## Semantic Design Contract — before writing checker.cpp
+
+Create the analysis portions of `state.json` and `scope_statement.md` **before**
+writing checker.cpp. They are a design contract, not a retrospective summary.
+After compilation, update only implementation facts such as `build_attempts`.
+
+In `patch_analysis`, distinguish the vulnerable operation, its trigger, and the
+semantic fact introduced by the patch that makes it safe. In `detection_plan`,
+make `report_condition`, `safe_condition`, and `source_level_signal` concrete
+CSA-observable facts. In `api_choice`, record the mechanism level and explain
+why the selected callback can observe and prove those facts.
+
+In `scope_statement.md`, include this mapping table and check it again after
+implementation:
+
+| Semantic condition | CSA evidence | checker.cpp implementation |
+| --- | --- | --- |
+| report condition | AST / SVal / MemRegion / CFG evidence | callback, helper, and branch that reports |
+| safe condition | path constraint, guard, state discharge, or structural fact | branch that suppresses the report |
+
+Every condition in the plan must have an implementation entry. Do not claim a
+condition that checker.cpp does not implement, and do not silently add a code
+condition absent from the plan.
+
+## Mechanism Selection — diagnose before coding
+
+Choose the weakest CSA mechanism that can prove the vulnerability property:
+
+1. **syntax-only AST**: only when local AST shape itself is the defect;
+2. **control flow / dominance**: when guard placement relative to a sink matters;
+3. **path-sensitive ProgramState/SVal**: when an unsafe state must reach a use;
+4. **cross-procedure/dataflow**: when the required fact crosses function boundaries.
+
+For a guard-based patch, prove both that the guard rejects the unsafe value and
+that it dominates the vulnerable use. For path-sensitive or cross-procedure
+defects, do not replace the required state or flow proof with local AST matching
+or source-text substring matching merely because it passes the differential scan.
+Record the selected level as `api_choice.mechanism_level`.
+
+## Semantic identity, locality, and final validation
+
+Before accepting the checker, verify that its primary matching logic does not
+depend on patch-local variable names, labels, line numbers, commit IDs, or unique
+literals. Project APIs, types, and stable semantic call relationships are valid
+scope anchors when they define the vulnerability class. Attach the report to the
+actual vulnerable operation, and implement every suppression as a real safe
+condition rather than the mere presence of a nearby guard-shaped statement.
+
+The required final sequence is: **compile → before scan → after scan → inspect
+the final checker name, artifacts, and report locations → write summary.json**.
+Always run the final compile and both scans. `MAX_IN_SESSION_REDESIGNS` limits only
+additional redesign cycles after a failed validation; if it is zero, preserve the
+real validation evidence and report failure honestly rather than fabricating counts.
+
+## Validation Criteria
+
+```
+VALID   : N_buggy > N_patched  AND  N_patched < 50
+INVALID : otherwise → revise and re-validate (max 1 attempts)
+```
+
+## Refinement
+
+Do NOT self-refine the checker repeatedly. Your goal is to produce the first
+checker that passes the Validation Criteria above — fix compile errors and
+validation failures only. False positives are triaged and repaired by the
+framework's refinement stage: you will receive a concrete FP list via
+session resume (if needed) and fix only those. Reserve budget for that stage.
+
+## Output
+
+Produce all of the following **only when completely done**:
+
+| File | Content |
+|------|---------|
+| ``checker.cpp`` | Synthesized checker source code |
+| ``checker.so`` | Compiled checker plugin |
+| ``state.json`` | Structured task state (see schema below) |
+| ``scope_statement.md`` | Checker scope analysis in prose (Level 1/2/3) |
+| ``summary.json`` | Final report (see schema below) |
+
+Writing ``summary.json`` signals completion.  Do NOT write it early.
+
+### ``state.json``
+
+Create this before writing checker.cpp to capture the design contract. After the
+checker compiles, update only implementation facts and retain the original
+semantic plan.
+
+```json
+{
+  "patch_analysis": {
+    "summary":           "One sentence describing the vulnerability this patch fixes",
+    "changed_files":     ["file1.c", "file2.h"],
+    "changed_functions": ["func_a", "func_b"],
+    "bug_type":          "buffer_overflow | use_after_free | null_deref | integer_overflow | race_condition | resource_leak | double_free | input_validation | other",
+    "fix_strategy":      "add_bounds_check | add_null_check | add_size_check | add_early_return | reorder_operations | change_api_signature | other",
+    "affected_types":    ["GF_BitStream", "custom_struct_t"],
+    "critical_calls":    ["gf_strdup", "memcpy"]
+  },
+  "detection_plan": {
+    "bug_pattern":         "High-level description of the vulnerability pattern (e.g. 'heap buffer overflow when reading variable-length data into a fixed-size stack buffer without size bound')",
+    "report_condition":    "When should the checker emit a warning? (e.g. 'call to gf_strdup where the argument originates from a fixed-size local array that was populated by variable-length bitstream reads')",
+    "safe_condition":      "When should the checker NOT emit a warning? (e.g. 'argument originates from a heap allocation or a size-bounded source')",
+    "source_level_signal": "What AST / MemRegion / SVal property does the checker look for? (e.g. 'MemRegion extent < parameter size at a PreCall to gf_strdup')"
+  },
+  "api_choice": {
+    "mechanism_level":          "syntactic_ast | control_flow | path_sensitive | interprocedural_dataflow",
+    "callback":                 "check::PreCall | check::PostCall | check::PreStmt | check::PostStmt | check::Bind | check::DeadSymbols | check::EndFunction | ...",
+    "reasoning":                "Why this callback and its AST/state/CFG evidence prove the report and safe conditions",
+    "alternatives_considered":  ["check::PostCall"]
+  },
+  "implementation": {
+    "scope_level":    "patch_specific | project_general | cross_project",
+    "checker_name":   "project.CheckerName",
+    "build_attempts": 1
+  }
+}
+```
+
+### ``summary.json``
+
+```json
+{
+  "status":           "plausible | failed",
+  "bug_pattern":      "One sentence describing the bug pattern",
+  "scope_level":      "patch_specific | project_general | cross_project",
+  "checker_cpp":      "checker.cpp",
+  "checker_so":       "checker.so",
+  "n_buggy":          0,
+  "n_patched":        0,
+  "total_reports":    0,
+  "fp_rate_estimate": 0.0,
+  "failure_reason":   null
+}
+```
+
+## Feedback-derived requirements for this fresh synthesis
+
+A prior independent rollout exposed the risks below. Start again from the patch
+in this new session. Do not reconstruct, edit, or assume the prior checker.
+
+Required mechanism level: `interprocedural_dataflow`
+
+### Current failure diagnosis
+
+- The prior rollout detected a generic negative destination offset but did not prove the specific defect fixed by the patch: a length measured by get_kobj_path_length() becoming stale before fill_kobj_path() writes into the allocation.
+- It did not establish that path is the beginning of the allocation returned by kzalloc(), nor relate the allocation extent to the later memcpy and decremented store.
+- It had no model for the relationship between the sizing and filling operations or for concurrent kobject name or ancestry growth, so its reports covered a superset of the patched defect.
+- The final refinement, semantic mechanism, and semantic score checks failed even though compilation, differential validation, scope sharpness, and hardcoding checks passed.
+
+### Preserve from prior rollouts
+
+- Preserve successful compilation, before/after validation, and code verification.
+- Preserve objective eligibility gate G6.
+- Preserve at least the previously adequate path-sensitive CSA reasoning level.
+- Preserve semantic score at or above the configured threshold and process quality at or above its configured threshold.
+- Do not introduce dependence on patch anchors, patch-local identifiers, literals, line numbers, or source-text matching.
+- Keep the checker project-general and free of patch-local hardcoding.
+
+### Required semantic proof
+
+- Establish that a destination write can occur through a pointer derived from the allocation base, with an effective offset that is negative relative to the beginning of that allocation.
+- Track the allocation size or available extent from the allocation-producing operation and relate it to the length computed before the fill operation.
+- Connect the value returned or established by get_kobj_path_length() with the length consumed by fill_kobj_path(), including the intervening allocation and function boundary.
+- Establish that the write is reachable without a terminating condition proving the effective offset is non-negative, and that the patched length <= 0 return excludes the corresponding unsafe path.
+- Represent the stale-size condition caused by a possible change in the kobject name or ancestry between measurement and filling sufficiently to distinguish the fixed race from unrelated negative arithmetic.
+- Keep the claimed defect precise: the write begins before the allocated path buffer; do not infer that every negative arithmetic expression is an out-of-bounds access.
+
+### Implementation constraints
+
+- Use CSA path-sensitive ProgramState and ConstraintManager facts at the write sink, combined with interprocedural propagation across the sizing, allocation, and filling functions.
+- Model destination-writing calls such as memcpy and direct pointer stores only when their destination can be tied to the tracked allocation base and effective offset.
+- Preserve correct handling of pointer arithmetic, nested element or field regions, signed values, and pre/post-decrement side effects without manually re-evaluating expressions.
+- Carry allocation extent and relevant length provenance through returns, arguments, and aliases rather than recognizing only local AST shapes.
+- Use CFG reachability and terminating guards to suppress the patched paths, while reporting at the concrete write location with a path-sensitive diagnostic.
+- Keep matching structural and semantic; do not special-case fill_kobj_path, get_kobj_path_length, kobject_get_path, kobject, path, length, or patch-specific APIs.
+- Limit reports to the project-general stale-size allocation/write relation and avoid broad classification of arbitrary writable byte-pointer calls without established provenance.
+
+### Validation checklist
+
+- Compile the new checker and retain code verification success.
+- Scan the supplied pre-patch source and confirm the expected vulnerable writes are reported at or near the memcpy and direct-store sinks.
+- Scan the supplied post-patch source and confirm those reports disappear because the terminating guard and retry path exclude the unsafe relation.
+- Verify report locations belong to the changed functions and remain within the established diagnostic-distance threshold.
+- Check that the before/after result preserves objective gate G6, including differential detection, sharpness, and non-patched-function false-positive control.
+- Exercise a refinement set with nonnegative guarded offsets, interior pointers, concrete offsets, unrelated negative arithmetic, and writes lacking allocation provenance.
+- Confirm the checker remains patch-anchor-free and patch-hardcoding-free under implementation and scan checks.
+- Require refinement acceptance, semantic mechanism adequacy, semantic correctness, and semantic score threshold success before rollout.
+
+### Avoid and forbidden regressions
+
+- Do not treat any feasible negative symbolic offset as sufficient evidence of this vulnerability.
+- Do not rely solely on local PreCall or PreStmt destination shape without allocation extent and cross-function provenance.
+- Do not force all pointer offsets into a signed interpretation when the source semantics do not establish that interpretation.
+- Do not broadly classify every mutable byte-buffer first parameter as a destination sink without proving the relevant write and allocation relationship.
+- Do not claim that a nonnegative offset proves the entire write range fits within the allocation.
+- Do not model the patch by matching its function names, variable names, guard text, changed lines, or literal constants.
+- Do not regress the successful compile, validation, objective-gate, scope-control, semantic-level, semantic-score, process-quality, anchor-free, or hardcoding-free checks.

tasks/csa159/pair_164140/checker_template.cpp

@@ -0,0 +1,98 @@
+// ============================================================================
+// CSA Checker Template
+// ============================================================================
+// Fill in the sections marked with TODO to implement your checker.
+// The checker is compiled with -fno-rtti to match the LLVM 18 build config.
+// It is loaded via: clang -cc1 -load checker.so -analyzer-checker=your.CheckerName
+//
+// Compilation:
+//   clang++ -std=c++17 -fPIC -shared -fno-rtti -fno-exceptions \
+//           -I${LLVM_BUILD_DIR}/include \
+//           checker.cpp -o checker.so \
+//           -Wl,--allow-shlib-undefined
+//
+// Usage:
+//   clang -cc1 -load ./checker.so -analyzer-checker=your.CheckerName -analyze <file>
+// ============================================================================
+
+#include "clang/StaticAnalyzer/Core/BugReporter/BugReporter.h"
+#include "clang/StaticAnalyzer/Core/BugReporter/BugType.h"
+#include "clang/StaticAnalyzer/Core/Checker.h"
+#include "clang/StaticAnalyzer/Core/PathSensitive/CallEvent.h"
+#include "clang/StaticAnalyzer/Core/PathSensitive/CheckerContext.h"
+#include "clang/StaticAnalyzer/Frontend/CheckerRegistry.h"
+
+using namespace clang;
+using namespace ento;
+
+namespace {
+
+// ────────────────────────────────────────────────────────────────
+// TODO: Rename this class to describe your checker's purpose.
+// ────────────────────────────────────────────────────────────────
+class {{CHECKER_CLASS_NAME}}
+    : public Checker<check::PreCall,      // for checking before function calls
+                     check::PostCall>     // for checking after function calls
+{
+  // TODO: Customize the bug type name and category.
+  mutable std::unique_ptr<BugType> BT;
+
+public:
+  {{CHECKER_CLASS_NAME}}()
+      : BT(new BugType(this, "{{BUG_NAME}}", "{{BUG_CATEGORY}}")) {}
+
+  // ── PreCall callback (fires before every function call) ──────
+  void checkPreCall(const CallEvent &Call, CheckerContext &C) const {
+    // TODO: Implement your pre-call analysis logic here.
+    //
+    // Common patterns:
+    //
+    // 1. Check if the called function matches a specific name:
+    //    if (Call.getCalleeIdentifier()) {
+    //      StringRef name = Call.getCalleeIdentifier()->getName();
+    //      if (name == "target_function") { ... }
+    //    }
+    //
+    // 2. Get the program state:
+    //    ProgramStateRef State = C.getState();
+    //
+    // 3. Get arguments:
+    //    SVal Arg = Call.getArgSVal(0);
+    //
+    // 4. Generate a bug report:
+    //    ExplodedNode *ErrNode = C.generateErrorNode();
+    //    if (ErrNode) {
+    //      auto R = std::make_unique<PathSensitiveBugReport>(
+    //          *BT, "Description of the bug", ErrNode);
+    //      C.emitReport(std::move(R));
+    //    }
+  }
+
+  // ── PostCall callback (fires after every function call) ─────
+  void checkPostCall(const CallEvent &Call, CheckerContext &C) const {
+    // TODO: Implement your post-call analysis logic here.
+    //
+    // Common pattern — check the return value:
+    //   SVal RetVal = Call.getReturnValue();
+    //   if (RetVal.isUnknownOrUndef()) return;
+    //
+    //   ProgramStateRef State = C.getState();
+    //   // Modify state based on post-call conditions...
+  }
+};
+
+} // anonymous namespace
+
+// ────────────────────────────────────────────────────────────────
+// Registration — DO NOT modify the function signatures.
+// ────────────────────────────────────────────────────────────────
+
+extern "C" void clang_registerCheckers(CheckerRegistry &registry) {
+  registry.addChecker<{{CHECKER_CLASS_NAME}}>(
+      "{{CHECKER_FULL_NAME}}",  // e.g., "your.NullDereferenceChecker"
+      "{{CHECKER_DESC}}",       // e.g., "Detects null pointer dereference"
+      "{{CHECKER_DOC_URI}}");   // e.g., "https://example.com/docs"
+}
+
+extern "C" const char clang_analyzerAPIVersionString[] =
+    CLANG_ANALYZER_API_VERSION_STRING;

tasks/csa159/pair_164140/config.json

@@ -0,0 +1,19 @@
+{
+  "project_id": "torvalds_linux",
+  "before_commit": "60316d7f10b17a7ebb1ead0642fee8710e1560e0",
+  "after_commit": "23d05d563b7e7b0314e65c8e882bc27eac2da8e7",
+  "repo_path": "/workspace/repo/torvalds/linux",
+  "llvm_build_dir": "/opt/llvm",
+  "before_compile_commands": "/workspace/benchmark/data-pipeline/snapshots/torvalds_linux/33cc938e65a98f1d29d0a18403dbbee050dcad9a/compile_commands.json",
+  "after_compile_commands": "/workspace/benchmark/data-pipeline/snapshots/torvalds_linux/33cc938e65a98f1d29d0a18403dbbee050dcad9a/compile_commands.json",
+  "changed_files": [
+    "net/core/skbuff.c"
+  ],
+  "commit_message": "net: prevent mss overflow in skb_segment()\n\nOnce again syzbot is able to crash the kernel in skb_segment() [1]\n\nGSO_BY_FRAGS is a forbidden value, but unfortunately the following\ncomputation in skb_segment() can reach it quite easily :\n\n\tmss = mss * partial_segs;\n\n65535 = 3 * 5 * 17 * 257, so many initial values of mss can lead to\na bad final result.\n\nMake sure to limit segmentation so that the new mss value is smaller\nthan GSO_BY_FRAGS.\n\n[1]\n\ngeneral protection fault, probably for non-canonical address 0xdffffc000000000e: 0000 [#1] PREEMPT SMP KASAN\nKASAN: null-ptr-deref in range [0x0000000000000070-0x0000000000000077]\nCPU: 1 PID: 5079 Comm: syz-executor993 Not tainted 6.7.0-rc4-syzkaller-00141-g1ae4cd3cbdd0 #0\nHardware name: Google Google Compute Engine/Google Compute Engine, BIOS Google 11/10/2023\nRIP: 0010:skb_segment+0x181d/0x3f30 net/core/skbuff.c:4551\nCode: 83 e3 02 e9 fb ed ff ff e8 90 68 1c f9 48 8b 84 24 f8 00 00 00 48 8d 78 70 48 b8 00 00 00 00 00 fc ff df 48 89 fa 48 c1 ea 03 <0f> b6 04 02 84 c0 74 08 3c 03 0f 8e 8a 21 00 00 48 8b 84 24 f8 00\nRSP: 0018:ffffc900043473d0 EFLAGS: 00010202\nRAX: dffffc0000000000 RBX: 0000000000010046 RCX: ffffffff886b1597\nRDX: 000000000000000e RSI: ffffffff886b2520 RDI: 0000000000000070\nRBP: ffffc90004347578 R08: 0000000000000005 R09: 000000000000ffff\nR10: 000000000000ffff R11: 0000000000000002 R12: ffff888063202ac0\nR13: 0000000000010000 R14: 000000000000ffff R15: 0000000000000046\nFS: 0000555556e7e380(0000) GS:ffff8880b9900000(0000) knlGS:0000000000000000\nCS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033\nCR2: 0000000020010000 CR3: 0000000027ee2000 CR4: 00000000003506f0\nDR0: 0000000000000000 DR1: 0000000000000000 DR2: 0000000000000000\nDR3: 0000000000000000 DR6: 00000000fffe0ff0 DR7: 0000000000000400\nCall Trace:\n<TASK>\nudp6_ufo_fragment+0xa0e/0xd00 net/ipv6/udp_offload.c:109\nipv6_gso_segment+0x534/0x17e0 net/ipv6/ip6_offload.c:120\nskb_mac_gso_segment+0x290/0x610 net/core/gso.c:53\n__skb_gso_segment+0x339/0x710 net/core/gso.c:124\nskb_gso_segment include/net/gso.h:83 [inline]\nvalidate_xmit_skb+0x36c/0xeb0 net/core/dev.c:3626\n__dev_queue_xmit+0x6f3/0x3d60 net/core/dev.c:4338\ndev_queue_xmit include/linux/netdevice.h:3134 [inline]\npacket_xmit+0x257/0x380 net/packet/af_packet.c:276\npacket_snd net/packet/af_packet.c:3087 [inline]\npacket_sendmsg+0x24c6/0x5220 net/packet/af_packet.c:3119\nsock_sendmsg_nosec net/socket.c:730 [inline]\n__sock_sendmsg+0xd5/0x180 net/socket.c:745\n__sys_sendto+0x255/0x340 net/socket.c:2190\n__do_sys_sendto net/socket.c:2202 [inline]\n__se_sys_sendto net/socket.c:2198 [inline]\n__x64_sys_sendto+0xe0/0x1b0 net/socket.c:2198\ndo_syscall_x64 arch/x86/entry/common.c:52 [inline]\ndo_syscall_64+0x40/0x110 arch/x86/entry/common.c:83\nentry_SYSCALL_64_after_hwframe+0x63/0x6b\nRIP: 0033:0x7f8692032aa9\nCode: 28 00 00 00 75 05 48 83 c4 28 c3 e8 d1 19 00 00 90 48 89 f8 48 89 f7 48 89 d6 48 89 ca 4d 89 c2 4d 89 c8 4c 8b 4c 24 08 0f 05 <48> 3d 01 f0 ff ff 73 01 c3 48 c7 c1 b8 ff ff ff f7 d8 64 89 01 48\nRSP: 002b:00007fff8d685418 EFLAGS: 00000246 ORIG_RAX: 000000000000002c\nRAX: ffffffffffffffda RBX: 0000000000000003 RCX: 00007f8692032aa9\nRDX: 0000000000010048 RSI: 00000000200000c0 RDI: 0000000000000003\nRBP: 00000000000f4240 R08: 0000000020000540 R09: 0000000000000014\nR10: 0000000000000000 R11: 0000000000000246 R12: 00007fff8d685480\nR13: 0000000000000001 R14: 00007fff8d685480 R15: 0000000000000003\n</TASK>\nModules linked in:\n---[ end trace 0000000000000000 ]---\nRIP: 0010:skb_segment+0x181d/0x3f30 net/core/skbuff.c:4551\nCode: 83 e3 02 e9 fb ed ff ff e8 90 68 1c f9 48 8b 84 24 f8 00 00 00 48 8d 78 70 48 b8 00 00 00 00 00 fc ff df 48 89 fa 48 c1 ea 03 <0f> b6 04 02 84 c0 74 08 3c 03 0f 8e 8a 21 00 00 48 8b 84 24 f8 00\nRSP: 0018:ffffc900043473d0 EFLAGS: 00010202\nRAX: dffffc0000000000 RBX: 0000000000010046 RCX: ffffffff886b1597\nRDX: 000000000000000e RSI: ffffffff886b2520 RDI: 0000000000000070\nRBP: ffffc90004347578 R08: 0000000000000005 R09: 000000000000ffff\nR10: 000000000000ffff R11: 0000000000000002 R12: ffff888063202ac0\nR13: 0000000000010000 R14: 000000000000ffff R15: 0000000000000046\nFS: 0000555556e7e380(0000) GS:ffff8880b9900000(0000) knlGS:0000000000000000\nCS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033\nCR2: 0000000020010000 CR3: 0000000027ee2000 CR4: 00000000003506f0\nDR0: 0000000000000000 DR1: 0000000000000000 DR2: 0000000000000000\nDR3: 0000000000000000 DR6: 00000000fffe0ff0 DR7: 0000000000000400\n\nFixes: 3953c46c3ac7 (\"sk_buff: allow segmenting based on frag sizes\")\nSigned-off-by: Eric Dumazet <edumazet@google.com>\nCc: Marcelo Ricardo Leitner <marcelo.leitner@gmail.com>\nReviewed-by: Willem de Bruijn <willemb@google.com>\nLink: https://lore.kernel.org/r/20231212164621.4131800-1-edumazet@google.com\nSigned-off-by: Jakub Kicinski <kuba@kernel.org>",
+  "t_valid": 50,
+  "t_plausible": 20,
+  "triage_sample_size": 10,
+  "max_synthesis_retry": 0,
+  "max_in_session_redesigns": 1,
+  "max_refinement_iter": 3
+}

tasks/csa159/pair_164140/patch.diff

@@ -0,0 +1,15 @@
+diff --git a/net/core/skbuff.c b/net/core/skbuff.c
+index b157efea5dea..83af8aaeb893 100644
+--- a/net/core/skbuff.c
++++ b/net/core/skbuff.c
+@@ -4522,8 +4522,9 @@ struct sk_buff *skb_segment(struct sk_buff *head_skb,
+ 		/* GSO partial only requires that we trim off any excess that
+ 		 * doesn't fit into an MSS sized block, so take care of that
+ 		 * now.
++		 * Cap len to not accidentally hit GSO_BY_FRAGS.
+ 		 */
+-		partial_segs = len / mss;
++		partial_segs = min(len, GSO_BY_FRAGS - 1) / mss;
+ 		if (partial_segs > 1)
+ 			mss *= partial_segs;
+ 		else

tasks/csa159/pair_164140/post_functions.txt

@@ -0,0 +1,328 @@
+### File: net/core/skbuff.c
+```c
+struct sk_buff *skb_segment(struct sk_buff *head_skb,
+			    netdev_features_t features)
+{
+	struct sk_buff *segs = NULL;
+	struct sk_buff *tail = NULL;
+	struct sk_buff *list_skb = skb_shinfo(head_skb)->frag_list;
+	unsigned int mss = skb_shinfo(head_skb)->gso_size;
+	unsigned int doffset = head_skb->data - skb_mac_header(head_skb);
+	unsigned int offset = doffset;
+	unsigned int tnl_hlen = skb_tnl_header_len(head_skb);
+	unsigned int partial_segs = 0;
+	unsigned int headroom;
+	unsigned int len = head_skb->len;
+	struct sk_buff *frag_skb;
+	skb_frag_t *frag;
+	__be16 proto;
+	bool csum, sg;
+	int err = -ENOMEM;
+	int i = 0;
+	int nfrags, pos;
+
+	if ((skb_shinfo(head_skb)->gso_type & SKB_GSO_DODGY) &&
+	    mss != GSO_BY_FRAGS && mss != skb_headlen(head_skb)) {
+		struct sk_buff *check_skb;
+
+		for (check_skb = list_skb; check_skb; check_skb = check_skb->next) {
+			if (skb_headlen(check_skb) && !check_skb->head_frag) {
+				/* gso_size is untrusted, and we have a frag_list with
+				 * a linear non head_frag item.
+				 *
+				 * If head_skb's headlen does not fit requested gso_size,
+				 * it means that the frag_list members do NOT terminate
+				 * on exact gso_size boundaries. Hence we cannot perform
+				 * skb_frag_t page sharing. Therefore we must fallback to
+				 * copying the frag_list skbs; we do so by disabling SG.
+				 */
+				features &= ~NETIF_F_SG;
+				break;
+			}
+		}
+	}
+
+	__skb_push(head_skb, doffset);
+	proto = skb_network_protocol(head_skb, NULL);
+	if (unlikely(!proto))
+		return ERR_PTR(-EINVAL);
+
+	sg = !!(features & NETIF_F_SG);
+	csum = !!can_checksum_protocol(features, proto);
+
+	if (sg && csum && (mss != GSO_BY_FRAGS))  {
+		if (!(features & NETIF_F_GSO_PARTIAL)) {
+			struct sk_buff *iter;
+			unsigned int frag_len;
+
+			if (!list_skb ||
+			    !net_gso_ok(features, skb_shinfo(head_skb)->gso_type))
+				goto normal;
+
+			/* If we get here then all the required
+			 * GSO features except frag_list are supported.
+			 * Try to split the SKB to multiple GSO SKBs
+			 * with no frag_list.
+			 * Currently we can do that only when the buffers don't
+			 * have a linear part and all the buffers except
+			 * the last are of the same length.
+			 */
+			frag_len = list_skb->len;
+			skb_walk_frags(head_skb, iter) {
+				if (frag_len != iter->len && iter->next)
+					goto normal;
+				if (skb_headlen(iter) && !iter->head_frag)
+					goto normal;
+
+				len -= iter->len;
+			}
+
+			if (len != frag_len)
+				goto normal;
+		}
+
+		/* GSO partial only requires that we trim off any excess that
+		 * doesn't fit into an MSS sized block, so take care of that
+		 * now.
+		 * Cap len to not accidentally hit GSO_BY_FRAGS.
+		 */
+		partial_segs = min(len, GSO_BY_FRAGS - 1) / mss;
+		if (partial_segs > 1)
+			mss *= partial_segs;
+		else
+			partial_segs = 0;
+	}
+
+normal:
+	headroom = skb_headroom(head_skb);
+	pos = skb_headlen(head_skb);
+
+	if (skb_orphan_frags(head_skb, GFP_ATOMIC))
+		return ERR_PTR(-ENOMEM);
+
+	nfrags = skb_shinfo(head_skb)->nr_frags;
+	frag = skb_shinfo(head_skb)->frags;
+	frag_skb = head_skb;
+
+	do {
+		struct sk_buff *nskb;
+		skb_frag_t *nskb_frag;
+		int hsize;
+		int size;
+
+		if (unlikely(mss == GSO_BY_FRAGS)) {
+			len = list_skb->len;
+		} else {
+			len = head_skb->len - offset;
+			if (len > mss)
+				len = mss;
+		}
+
+		hsize = skb_headlen(head_skb) - offset;
+
+		if (hsize <= 0 && i >= nfrags && skb_headlen(list_skb) &&
+		    (skb_headlen(list_skb) == len || sg)) {
+			BUG_ON(skb_headlen(list_skb) > len);
+
+			nskb = skb_clone(list_skb, GFP_ATOMIC);
+			if (unlikely(!nskb))
+				goto err;
+
+			i = 0;
+			nfrags = skb_shinfo(list_skb)->nr_frags;
+			frag = skb_shinfo(list_skb)->frags;
+			frag_skb = list_skb;
+			pos += skb_headlen(list_skb);
+
+			while (pos < offset + len) {
+				BUG_ON(i >= nfrags);
+
+				size = skb_frag_size(frag);
+				if (pos + size > offset + len)
+					break;
+
+				i++;
+				pos += size;
+				frag++;
+			}
+
+			list_skb = list_skb->next;
+
+			if (unlikely(pskb_trim(nskb, len))) {
+				kfree_skb(nskb);
+				goto err;
+			}
+
+			hsize = skb_end_offset(nskb);
+			if (skb_cow_head(nskb, doffset + headroom)) {
+				kfree_skb(nskb);
+				goto err;
+			}
+
+			nskb->truesize += skb_end_offset(nskb) - hsize;
+			skb_release_head_state(nskb);
+			__skb_push(nskb, doffset);
+		} else {
+			if (hsize < 0)
+				hsize = 0;
+			if (hsize > len || !sg)
+				hsize = len;
+
+			nskb = __alloc_skb(hsize + doffset + headroom,
+					   GFP_ATOMIC, skb_alloc_rx_flag(head_skb),
+					   NUMA_NO_NODE);
+
+			if (unlikely(!nskb))
+				goto err;
+
+			skb_reserve(nskb, headroom);
+			__skb_put(nskb, doffset);
+		}
+
+		if (segs)
+			tail->next = nskb;
+		else
+			segs = nskb;
+		tail = nskb;
+
+		__copy_skb_header(nskb, head_skb);
+
+		skb_headers_offset_update(nskb, skb_headroom(nskb) - headroom);
+		skb_reset_mac_len(nskb);
+
+		skb_copy_from_linear_data_offset(head_skb, -tnl_hlen,
+						 nskb->data - tnl_hlen,
+						 doffset + tnl_hlen);
+
+		if (nskb->len == len + doffset)
+			goto perform_csum_check;
+
+		if (!sg) {
+			if (!csum) {
+				if (!nskb->remcsum_offload)
+					nskb->ip_summed = CHECKSUM_NONE;
+				SKB_GSO_CB(nskb)->csum =
+					skb_copy_and_csum_bits(head_skb, offset,
+							       skb_put(nskb,
+								       len),
+							       len);
+				SKB_GSO_CB(nskb)->csum_start =
+					skb_headroom(nskb) + doffset;
+			} else {
+				if (skb_copy_bits(head_skb, offset, skb_put(nskb, len), len))
+					goto err;
+			}
+			continue;
+		}
+
+		nskb_frag = skb_shinfo(nskb)->frags;
+
+		skb_copy_from_linear_data_offset(head_skb, offset,
+						 skb_put(nskb, hsize), hsize);
+
+		skb_shinfo(nskb)->flags |= skb_shinfo(head_skb)->flags &
+					   SKBFL_SHARED_FRAG;
+
+		if (skb_zerocopy_clone(nskb, frag_skb, GFP_ATOMIC))
+			goto err;
+
+		while (pos < offset + len) {
+			if (i >= nfrags) {
+				if (skb_orphan_frags(list_skb, GFP_ATOMIC) ||
+				    skb_zerocopy_clone(nskb, list_skb,
+						       GFP_ATOMIC))
+					goto err;
+
+				i = 0;
+				nfrags = skb_shinfo(list_skb)->nr_frags;
+				frag = skb_shinfo(list_skb)->frags;
+				frag_skb = list_skb;
+				if (!skb_headlen(list_skb)) {
+					BUG_ON(!nfrags);
+				} else {
+					BUG_ON(!list_skb->head_frag);
+
+					/* to make room for head_frag. */
+					i--;
+					frag--;
+				}
+
+				list_skb = list_skb->next;
+			}
+
+			if (unlikely(skb_shinfo(nskb)->nr_frags >=
+				     MAX_SKB_FRAGS)) {
+				net_warn_ratelimited(
+					"skb_segment: too many frags: %u %u\n",
+					pos, mss);
+				err = -EINVAL;
+				goto err;
+			}
+
+			*nskb_frag = (i < 0) ? skb_head_frag_to_page_desc(frag_skb) : *frag;
+			__skb_frag_ref(nskb_frag);
+			size = skb_frag_size(nskb_frag);
+
+			if (pos < offset) {
+				skb_frag_off_add(nskb_frag, offset - pos);
+				skb_frag_size_sub(nskb_frag, offset - pos);
+			}
+
+			skb_shinfo(nskb)->nr_frags++;
+
+			if (pos + size <= offset + len) {
+				i++;
+				frag++;
+				pos += size;
+			} else {
+				skb_frag_size_sub(nskb_frag, pos + size - (offset + len));
+				goto skip_fraglist;
+			}
+
+			nskb_frag++;
+		}
+
+skip_fraglist:
+		nskb->data_len = len - hsize;
+		nskb->len += nskb->data_len;
+		nskb->truesize += nskb->data_len;
+
+perform_csum_check:
+		if (!csum) {
+			if (skb_has_shared_frag(nskb) &&
+			    __skb_linearize(nskb))
+				goto err;
+
+			if (!nskb->remcsum_offload)
+				nskb->ip_summed = CHECKSUM_NONE;
+			SKB_GSO_CB(nskb)->csum =
+				skb_checksum(nskb, doffset,
+					     nskb->len - doffset, 0);
+			SKB_GSO_CB(nskb)->csum_start =
+				skb_headroom(nskb) + doffset;
+		}
+	} while ((offset += len) < head_skb->len);
+
+	/* Some callers want to get the end of the list.
+	 * Put it in segs->prev to avoid walking the list.
+	 * (see validate_xmit_skb_list() for example)
+	 */
+	segs->prev = tail;
+
+	if (partial_segs) {
+		struct sk_buff *iter;
+		int type = skb_shinfo(head_skb)->gso_type;
+		unsigned short gso_size = skb_shinfo(head_skb)->gso_size;
+
+		/* Update type to add partial and then remove dodgy if set */
+		type |= (features & NETIF_F_GSO_PARTIAL) / NETIF_F_GSO_PARTIAL * SKB_GSO_PARTIAL;
+		type &= ~SKB_GSO_DODGY;
+
+		/* Update GSO info and prepare to start updating headers on
+		 * our way back down the stack of protocols.
+		 */
+		for (iter = segs; iter; iter = iter->next) {
+			skb_shi
+
+// ... (759 more chars)
+```

tasks/csa159/pair_164140/pre_functions.txt

@@ -0,0 +1,328 @@
+### File: net/core/skbuff.c
+```c
+struct sk_buff *skb_segment(struct sk_buff *head_skb,
+			    netdev_features_t features)
+{
+	struct sk_buff *segs = NULL;
+	struct sk_buff *tail = NULL;
+	struct sk_buff *list_skb = skb_shinfo(head_skb)->frag_list;
+	unsigned int mss = skb_shinfo(head_skb)->gso_size;
+	unsigned int doffset = head_skb->data - skb_mac_header(head_skb);
+	unsigned int offset = doffset;
+	unsigned int tnl_hlen = skb_tnl_header_len(head_skb);
+	unsigned int partial_segs = 0;
+	unsigned int headroom;
+	unsigned int len = head_skb->len;
+	struct sk_buff *frag_skb;
+	skb_frag_t *frag;
+	__be16 proto;
+	bool csum, sg;
+	int err = -ENOMEM;
+	int i = 0;
+	int nfrags, pos;
+
+	if ((skb_shinfo(head_skb)->gso_type & SKB_GSO_DODGY) &&
+	    mss != GSO_BY_FRAGS && mss != skb_headlen(head_skb)) {
+		struct sk_buff *check_skb;
+
+		for (check_skb = list_skb; check_skb; check_skb = check_skb->next) {
+			if (skb_headlen(check_skb) && !check_skb->head_frag) {
+				/* gso_size is untrusted, and we have a frag_list with
+				 * a linear non head_frag item.
+				 *
+				 * If head_skb's headlen does not fit requested gso_size,
+				 * it means that the frag_list members do NOT terminate
+				 * on exact gso_size boundaries. Hence we cannot perform
+				 * skb_frag_t page sharing. Therefore we must fallback to
+				 * copying the frag_list skbs; we do so by disabling SG.
+				 */
+				features &= ~NETIF_F_SG;
+				break;
+			}
+		}
+	}
+
+	__skb_push(head_skb, doffset);
+	proto = skb_network_protocol(head_skb, NULL);
+	if (unlikely(!proto))
+		return ERR_PTR(-EINVAL);
+
+	sg = !!(features & NETIF_F_SG);
+	csum = !!can_checksum_protocol(features, proto);
+
+	if (sg && csum && (mss != GSO_BY_FRAGS))  {
+		if (!(features & NETIF_F_GSO_PARTIAL)) {
+			struct sk_buff *iter;
+			unsigned int frag_len;
+
+			if (!list_skb ||
+			    !net_gso_ok(features, skb_shinfo(head_skb)->gso_type))
+				goto normal;
+
+			/* If we get here then all the required
+			 * GSO features except frag_list are supported.
+			 * Try to split the SKB to multiple GSO SKBs
+			 * with no frag_list.
+			 * Currently we can do that only when the buffers don't
+			 * have a linear part and all the buffers except
+			 * the last are of the same length.
+			 */
+			frag_len = list_skb->len;
+			skb_walk_frags(head_skb, iter) {
+				if (frag_len != iter->len && iter->next)
+					goto normal;
+				if (skb_headlen(iter) && !iter->head_frag)
+					goto normal;
+
+				len -= iter->len;
+			}
+
+			if (len != frag_len)
+				goto normal;
+		}
+
+		/* GSO partial only requires that we trim off any excess that
+		 * doesn't fit into an MSS sized block, so take care of that
+		 * now.
+		 */
+		partial_segs = len / mss;
+		if (partial_segs > 1)
+			mss *= partial_segs;
+		else
+			partial_segs = 0;
+	}
+
+normal:
+	headroom = skb_headroom(head_skb);
+	pos = skb_headlen(head_skb);
+
+	if (skb_orphan_frags(head_skb, GFP_ATOMIC))
+		return ERR_PTR(-ENOMEM);
+
+	nfrags = skb_shinfo(head_skb)->nr_frags;
+	frag = skb_shinfo(head_skb)->frags;
+	frag_skb = head_skb;
+
+	do {
+		struct sk_buff *nskb;
+		skb_frag_t *nskb_frag;
+		int hsize;
+		int size;
+
+		if (unlikely(mss == GSO_BY_FRAGS)) {
+			len = list_skb->len;
+		} else {
+			len = head_skb->len - offset;
+			if (len > mss)
+				len = mss;
+		}
+
+		hsize = skb_headlen(head_skb) - offset;
+
+		if (hsize <= 0 && i >= nfrags && skb_headlen(list_skb) &&
+		    (skb_headlen(list_skb) == len || sg)) {
+			BUG_ON(skb_headlen(list_skb) > len);
+
+			nskb = skb_clone(list_skb, GFP_ATOMIC);
+			if (unlikely(!nskb))
+				goto err;
+
+			i = 0;
+			nfrags = skb_shinfo(list_skb)->nr_frags;
+			frag = skb_shinfo(list_skb)->frags;
+			frag_skb = list_skb;
+			pos += skb_headlen(list_skb);
+
+			while (pos < offset + len) {
+				BUG_ON(i >= nfrags);
+
+				size = skb_frag_size(frag);
+				if (pos + size > offset + len)
+					break;
+
+				i++;
+				pos += size;
+				frag++;
+			}
+
+			list_skb = list_skb->next;
+
+			if (unlikely(pskb_trim(nskb, len))) {
+				kfree_skb(nskb);
+				goto err;
+			}
+
+			hsize = skb_end_offset(nskb);
+			if (skb_cow_head(nskb, doffset + headroom)) {
+				kfree_skb(nskb);
+				goto err;
+			}
+
+			nskb->truesize += skb_end_offset(nskb) - hsize;
+			skb_release_head_state(nskb);
+			__skb_push(nskb, doffset);
+		} else {
+			if (hsize < 0)
+				hsize = 0;
+			if (hsize > len || !sg)
+				hsize = len;
+
+			nskb = __alloc_skb(hsize + doffset + headroom,
+					   GFP_ATOMIC, skb_alloc_rx_flag(head_skb),
+					   NUMA_NO_NODE);
+
+			if (unlikely(!nskb))
+				goto err;
+
+			skb_reserve(nskb, headroom);
+			__skb_put(nskb, doffset);
+		}
+
+		if (segs)
+			tail->next = nskb;
+		else
+			segs = nskb;
+		tail = nskb;
+
+		__copy_skb_header(nskb, head_skb);
+
+		skb_headers_offset_update(nskb, skb_headroom(nskb) - headroom);
+		skb_reset_mac_len(nskb);
+
+		skb_copy_from_linear_data_offset(head_skb, -tnl_hlen,
+						 nskb->data - tnl_hlen,
+						 doffset + tnl_hlen);
+
+		if (nskb->len == len + doffset)
+			goto perform_csum_check;
+
+		if (!sg) {
+			if (!csum) {
+				if (!nskb->remcsum_offload)
+					nskb->ip_summed = CHECKSUM_NONE;
+				SKB_GSO_CB(nskb)->csum =
+					skb_copy_and_csum_bits(head_skb, offset,
+							       skb_put(nskb,
+								       len),
+							       len);
+				SKB_GSO_CB(nskb)->csum_start =
+					skb_headroom(nskb) + doffset;
+			} else {
+				if (skb_copy_bits(head_skb, offset, skb_put(nskb, len), len))
+					goto err;
+			}
+			continue;
+		}
+
+		nskb_frag = skb_shinfo(nskb)->frags;
+
+		skb_copy_from_linear_data_offset(head_skb, offset,
+						 skb_put(nskb, hsize), hsize);
+
+		skb_shinfo(nskb)->flags |= skb_shinfo(head_skb)->flags &
+					   SKBFL_SHARED_FRAG;
+
+		if (skb_zerocopy_clone(nskb, frag_skb, GFP_ATOMIC))
+			goto err;
+
+		while (pos < offset + len) {
+			if (i >= nfrags) {
+				if (skb_orphan_frags(list_skb, GFP_ATOMIC) ||
+				    skb_zerocopy_clone(nskb, list_skb,
+						       GFP_ATOMIC))
+					goto err;
+
+				i = 0;
+				nfrags = skb_shinfo(list_skb)->nr_frags;
+				frag = skb_shinfo(list_skb)->frags;
+				frag_skb = list_skb;
+				if (!skb_headlen(list_skb)) {
+					BUG_ON(!nfrags);
+				} else {
+					BUG_ON(!list_skb->head_frag);
+
+					/* to make room for head_frag. */
+					i--;
+					frag--;
+				}
+
+				list_skb = list_skb->next;
+			}
+
+			if (unlikely(skb_shinfo(nskb)->nr_frags >=
+				     MAX_SKB_FRAGS)) {
+				net_warn_ratelimited(
+					"skb_segment: too many frags: %u %u\n",
+					pos, mss);
+				err = -EINVAL;
+				goto err;
+			}
+
+			*nskb_frag = (i < 0) ? skb_head_frag_to_page_desc(frag_skb) : *frag;
+			__skb_frag_ref(nskb_frag);
+			size = skb_frag_size(nskb_frag);
+
+			if (pos < offset) {
+				skb_frag_off_add(nskb_frag, offset - pos);
+				skb_frag_size_sub(nskb_frag, offset - pos);
+			}
+
+			skb_shinfo(nskb)->nr_frags++;
+
+			if (pos + size <= offset + len) {
+				i++;
+				frag++;
+				pos += size;
+			} else {
+				skb_frag_size_sub(nskb_frag, pos + size - (offset + len));
+				goto skip_fraglist;
+			}
+
+			nskb_frag++;
+		}
+
+skip_fraglist:
+		nskb->data_len = len - hsize;
+		nskb->len += nskb->data_len;
+		nskb->truesize += nskb->data_len;
+
+perform_csum_check:
+		if (!csum) {
+			if (skb_has_shared_frag(nskb) &&
+			    __skb_linearize(nskb))
+				goto err;
+
+			if (!nskb->remcsum_offload)
+				nskb->ip_summed = CHECKSUM_NONE;
+			SKB_GSO_CB(nskb)->csum =
+				skb_checksum(nskb, doffset,
+					     nskb->len - doffset, 0);
+			SKB_GSO_CB(nskb)->csum_start =
+				skb_headroom(nskb) + doffset;
+		}
+	} while ((offset += len) < head_skb->len);
+
+	/* Some callers want to get the end of the list.
+	 * Put it in segs->prev to avoid walking the list.
+	 * (see validate_xmit_skb_list() for example)
+	 */
+	segs->prev = tail;
+
+	if (partial_segs) {
+		struct sk_buff *iter;
+		int type = skb_shinfo(head_skb)->gso_type;
+		unsigned short gso_size = skb_shinfo(head_skb)->gso_size;
+
+		/* Update type to add partial and then remove dodgy if set */
+		type |= (features & NETIF_F_GSO_PARTIAL) / NETIF_F_GSO_PARTIAL * SKB_GSO_PARTIAL;
+		type &= ~SKB_GSO_DODGY;
+
+		/* Update GSO info and prepare to start updating headers on
+		 * our way back down the stack of protocols.
+		 */
+		for (iter = segs; iter; iter = iter->next) {
+			skb_shinfo(iter)->gso_size = gso_size;
+			skb_shinfo(iter)->gso_segs = partial_se
+
+// ... (685 more chars)
+```

tasks/csa159/pair_164140/task_prompt.md

@@ -0,0 +1,380 @@
+# Task: Synthesize a CSA Checker from a CVE Patch
+
+## Your Role
+
+You are a static analysis expert. Synthesize a Clang Static Analyzer (CSA) checker
+that detects the bug pattern fixed by the CVE patch in this working directory.
+
+You have full filesystem and bash access — use them.
+
+### Skills
+
+Many skills are available under `.claude/skills/` — covering vulnerability analysis,
+checker design, debugging, code audit, security patterns, and more.  Each skill
+encodes reusable expertise: take time to explore them, read their SKILL.md files,
+and invoke those that look useful via the Skill tool.  Let the task guide which
+ones you reach for.
+
+## File Layout
+
+```
+/work/
+├── compile.sh               ← RUN ME: compile checker.cpp → checker.so
+├── checker_template.cpp     ← skeleton, start here
+├── patch.diff               ← the CVE fix
+├── pre_functions.txt        ← buggy source (before_commit)
+├── post_functions.txt       ← patched source (after_commit)
+├── config.json              ← paths, commit_message, commit hashes, flags
+├── scan/
+│   ├── scan_before.sh       ← RUN ME: scan before_commit → N_buggy
+│   ├── scan_after.sh        ← RUN ME: scan after_commit → N_patched
+│   └── flags_*.txt          ← pre-extracted compile flags (-I, -D)
+├── references/
+│   ├── repo_knowledge.md            ← project-specific API/convention reference
+│   ├── patterns_summary.md       ← (optional) historical bug pattern summary
+│   ├── cwe_cards/                ← CWE knowledge library (all categories)
+│   │   ├── index.json             ← lookup index — use to find relevant cards
+│   │   ├── CWE-{id}(-variant).md  ← Tier 1/2 per-CWE detection patterns
+│   │   ├── Category-{name}.md     ← Tier 3 umbrella cards (rare CWEs grouped)
+│   ├── csa_headers_api.md   ← API quick reference (extracted from LLVM 18 headers)
+│   ├── csa_checker_patterns.md ← pattern catalog (resource tracking, null check, etc.)
+│   ├── csa_utility_functions.h ← copy-paste C++ helpers for checker.cpp (AST traversal, expression eval, etc.)
+│   └── examples/
+│       └── llvm-official/   ← 5 official checker sources (with comments)
+│           ├── 01_div_zero.cpp
+│           ├── 02_simple_stream.cpp
+│           ├── 03_undef_result.cpp
+│           ├── 04_nullability.cpp
+│           └── 05_malloc.cpp
+│
+├── checker.cpp              ← YOUR OUTPUT: synthesized checker
+├── checker.so               ← YOUR OUTPUT: compiled checker
+├── state.json               ← YOUR OUTPUT: structured task state
+├── scope_statement.md       ← YOUR OUTPUT: checker scope analysis (Level 1/2/3)
+└── summary.json             ← YOUR OUTPUT: final report
+```
+
+## Resources
+
+**Read these before writing any code:**
+
+1. **`references/csa_headers_api.md`** — CSA API quick reference. Extracted directly from
+   LLVM 18 headers. Covers all checker callbacks, ProgramState operations, SVal types,
+   MemRegion hierarchy, and bug reporting. **Read this first whenever you need API info.**
+
+2. **`references/csa_checker_patterns.md`** — Pattern catalog. Documents 5 battle-tested
+   patterns from official LLVM checkers: resource tracking, null checking, undefined
+   value detection, division-by-zero, and malloc/free. Each pattern includes skeleton
+   code, state traits, and key API usage.
+
+3. **`references/examples/llvm-official/`** — 5 official LLVM 18 checker implementations
+   with explanatory comments:
+   - `01_div_zero.cpp` — simplest checker (169 lines, 1 callback)
+   - `02_simple_stream.cpp` — resource tracking (292 lines, fopen/fclose)
+   - `03_undef_result.cpp` — PostStmt pattern (160 lines)
+   - `04_nullability.cpp` — multi-callback checker (1247 lines)
+   - `05_malloc.cpp` — comprehensive malloc/free (1511 lines)
+
+4. **`checker_template.cpp`** — Skeleton with placeholders. Start here.
+
+5. **`references/repo_knowledge.md`** — Project-specific reference. Contains this
+   repository's memory allocation API, key data types, source layout, and typical
+   CVE patterns. **Read this before writing the checker** — knowing the project's
+   alloc/free conventions and common bug patterns saves many grep rounds.
+
+5b. **`references/patterns_summary.md`** — (may not exist) Historical synthesis
+   patterns for this project.  If present, it contains a concise summary of the
+   most common bug patterns, frequent CWE categories, and reusable checker
+   architectures observed in previous synthesis runs.  Read after repo_knowledge.md.
+
+6. **`references/cwe_cards/`** — Complete CWE knowledge base covering all
+   vulnerability categories.  **The framework provides the full library —
+   you must identify the vulnerability type yourself.**  Workflow:
+
+   1. Analyse the patch diff and commit message to determine the vulnerability
+      type (buffer overflow, UAF, null deref, integer overflow, race condition,
+      etc.).  Do NOT rely on the CWE label — treat it as a hint at most.
+   2. Open ``index.json`` to discover available cards and their tiers.
+   3. Read the relevant card(s) for **detection strategies**, **checker
+      architecture suggestions**, and **known false-positive patterns**.
+
+   Card tiers:
+   - ``CWE-{id}(-{variant}).md`` — Tier 1/2 cards for common CWEs; kernel /
+     userspace variants when the detection strategy differs substantially.
+   - ``Category-{name}.md`` — Tier 3 umbrella cards grouping rarer CWEs by
+     category (input validation, resource management, etc.).
+
+7. **`references/csa_utility_functions.h`** — Copy-paste C++ helper functions for
+   checker.cpp. Includes AST traversal (`findSpecificTypeInParents/Children`),
+   expression evaluation (`EvaluateExprToInt`, `inferSymbolMaxVal`), array/string
+   size extraction, MemRegion helpers, and `ExprHasName()` for robust function
+   matching. All verified against LLVM 18. **Read before implementing detection
+   logic** — these save writing boilerplate that's easy to get wrong.
+
+## Environment
+
+Key paths are in ``config.json``.
+
+### Pre-built scripts
+
+| Script | What it does |
+|--------|-------------|
+| `bash compile.sh` | Compile checker.cpp → checker.so (with correct flags) |
+| `CHECKER_NAME=<name> bash scan/scan_before.sh` | Scan before_commit, count warnings → N_buggy |
+| `CHECKER_NAME=<name> bash scan/scan_after.sh` | Scan after_commit, count warnings → N_patched |
+
+```bash
+# Compile (run from workdir root)
+bash compile.sh
+
+# Scan — set CHECKER_NAME to the string passed to addChecker<>()
+CHECKER_NAME=your.CheckerName bash scan/scan_before.sh   # → N_buggy
+CHECKER_NAME=your.CheckerName bash scan/scan_after.sh    # → N_patched
+```
+
+- ``compile.sh`` already has the correct ``-I`` / ``-fno-rtti`` flags.
+- ``scan/scan_*.sh`` count only warnings tagged with your checker name.
+- Scan environments (source files + compile flags) are pre-built in ``scan/``.
+
+### Scan Script Integrity (CRITICAL)
+
+The scan scripts (``scan/scan_before.sh``, ``scan/scan_after.sh``) are the **only
+valid measurement** of N_buggy and N_patched.  They are the ground truth that the
+Python-side validator will also use.  You MUST obey these rules:
+
+**1. Never bypass the scan scripts.**  Do NOT run ``clang --analyze`` directly
+   to measure warning counts.  The Python validator runs the same scan scripts
+   — if you measured with a different command, your numbers will not reproduce
+   and the synthesis will be rejected.
+
+**2. If the scan script prints COMPILE_ERROR** (missing headers, undeclared
+   identifiers, etc.), the scan environment needs repair.  You MUST fix it:
+   - Add missing ``-I`` include paths to the flags files in ``scan/``
+   - Copy needed generated headers (e.g. ``autoconf.h``) from the snapshot
+   - If the file fundamentally cannot be compiled by clang, stop and write
+     ``summary.json`` with ``status: "failed"`` and an honest ``failure_reason``
+
+**3. Only trust scan script output.**  The ``Total <name> warnings: N`` line
+   printed by the scan script is the number that goes into ``summary.json``.
+   If the scan script says 0, write 0.  Fabricating numbers that the scan
+   script did not produce will cause the Python validator to reject the
+   synthesis.
+
+- If compile fails: read the error, fix ``checker.cpp``, retry (max 3 cycles).
+- If validation fails: revise checker logic, re-compile, re-scan.
+
+## MCP Tools
+
+You have access to 3 MCP tools under the `csa-tools` server (prefixed `mcp__csa-tools__`).
+Each returns **source context embedded in the result** — no need to follow up with Read.
+
+| Tool | What it does | Key advantage |
+|------|-------------|---------------|
+| `search(pattern, scope)` | Search for a pattern in source / LLVM headers / workdir | Returns file:line + 3 lines context — grep + Read in one call |
+| `compile()` | Run compile.sh, return parsed diagnostics | Errors include checker.cpp context — fix without reading the file |
+| `scan(checker_name)` | Run before/after scan, return N_buggy + N_patched + warning locations | Each warning includes source context — no manual clang --analyze needed |
+
+### When to use each
+
+- **`search`**: Whenever you would type `grep -rn "X"` or `find ... -name`. Use `scope="source"` for CVE code, `scope="llvm"` for CSA API headers, `scope="all"` when unsure.
+- **`compile`**: Instead of `bash compile.sh` followed by reading checker.cpp at error lines.
+- **`scan`**: Instead of running scan_before.sh + scan_after.sh + manual clang inspection. Returns everything you need to decide next action.
+
+## Semantic Design Contract — before writing checker.cpp
+
+Create the analysis portions of `state.json` and `scope_statement.md` **before**
+writing checker.cpp. They are a design contract, not a retrospective summary.
+After compilation, update only implementation facts such as `build_attempts`.
+
+In `patch_analysis`, distinguish the vulnerable operation, its trigger, and the
+semantic fact introduced by the patch that makes it safe. In `detection_plan`,
+make `report_condition`, `safe_condition`, and `source_level_signal` concrete
+CSA-observable facts. In `api_choice`, record the mechanism level and explain
+why the selected callback can observe and prove those facts.
+
+In `scope_statement.md`, include this mapping table and check it again after
+implementation:
+
+| Semantic condition | CSA evidence | checker.cpp implementation |
+| --- | --- | --- |
+| report condition | AST / SVal / MemRegion / CFG evidence | callback, helper, and branch that reports |
+| safe condition | path constraint, guard, state discharge, or structural fact | branch that suppresses the report |
+
+Every condition in the plan must have an implementation entry. Do not claim a
+condition that checker.cpp does not implement, and do not silently add a code
+condition absent from the plan.
+
+## Mechanism Selection — diagnose before coding
+
+Choose the weakest CSA mechanism that can prove the vulnerability property:
+
+1. **syntax-only AST**: only when local AST shape itself is the defect;
+2. **control flow / dominance**: when guard placement relative to a sink matters;
+3. **path-sensitive ProgramState/SVal**: when an unsafe state must reach a use;
+4. **cross-procedure/dataflow**: when the required fact crosses function boundaries.
+
+For a guard-based patch, prove both that the guard rejects the unsafe value and
+that it dominates the vulnerable use. For path-sensitive or cross-procedure
+defects, do not replace the required state or flow proof with local AST matching
+or source-text substring matching merely because it passes the differential scan.
+Record the selected level as `api_choice.mechanism_level`.
+
+## Semantic identity, locality, and final validation
+
+Before accepting the checker, verify that its primary matching logic does not
+depend on patch-local variable names, labels, line numbers, commit IDs, or unique
+literals. Project APIs, types, and stable semantic call relationships are valid
+scope anchors when they define the vulnerability class. Attach the report to the
+actual vulnerable operation, and implement every suppression as a real safe
+condition rather than the mere presence of a nearby guard-shaped statement.
+
+The required final sequence is: **compile → before scan → after scan → inspect
+the final checker name, artifacts, and report locations → write summary.json**.
+Always run the final compile and both scans. `MAX_IN_SESSION_REDESIGNS` limits only
+additional redesign cycles after a failed validation; if it is zero, preserve the
+real validation evidence and report failure honestly rather than fabricating counts.
+
+## Validation Criteria
+
+```
+VALID   : N_buggy > N_patched  AND  N_patched < 50
+INVALID : otherwise → revise and re-validate (max 1 attempts)
+```
+
+## Refinement
+
+Do NOT self-refine the checker repeatedly. Your goal is to produce the first
+checker that passes the Validation Criteria above — fix compile errors and
+validation failures only. False positives are triaged and repaired by the
+framework's refinement stage: you will receive a concrete FP list via
+session resume (if needed) and fix only those. Reserve budget for that stage.
+
+## Output
+
+Produce all of the following **only when completely done**:
+
+| File | Content |
+|------|---------|
+| ``checker.cpp`` | Synthesized checker source code |
+| ``checker.so`` | Compiled checker plugin |
+| ``state.json`` | Structured task state (see schema below) |
+| ``scope_statement.md`` | Checker scope analysis in prose (Level 1/2/3) |
+| ``summary.json`` | Final report (see schema below) |
+
+Writing ``summary.json`` signals completion.  Do NOT write it early.
+
+### ``state.json``
+
+Create this before writing checker.cpp to capture the design contract. After the
+checker compiles, update only implementation facts and retain the original
+semantic plan.
+
+```json
+{
+  "patch_analysis": {
+    "summary":           "One sentence describing the vulnerability this patch fixes",
+    "changed_files":     ["file1.c", "file2.h"],
+    "changed_functions": ["func_a", "func_b"],
+    "bug_type":          "buffer_overflow | use_after_free | null_deref | integer_overflow | race_condition | resource_leak | double_free | input_validation | other",
+    "fix_strategy":      "add_bounds_check | add_null_check | add_size_check | add_early_return | reorder_operations | change_api_signature | other",
+    "affected_types":    ["GF_BitStream", "custom_struct_t"],
+    "critical_calls":    ["gf_strdup", "memcpy"]
+  },
+  "detection_plan": {
+    "bug_pattern":         "High-level description of the vulnerability pattern (e.g. 'heap buffer overflow when reading variable-length data into a fixed-size stack buffer without size bound')",
+    "report_condition":    "When should the checker emit a warning? (e.g. 'call to gf_strdup where the argument originates from a fixed-size local array that was populated by variable-length bitstream reads')",
+    "safe_condition":      "When should the checker NOT emit a warning? (e.g. 'argument originates from a heap allocation or a size-bounded source')",
+    "source_level_signal": "What AST / MemRegion / SVal property does the checker look for? (e.g. 'MemRegion extent < parameter size at a PreCall to gf_strdup')"
+  },
+  "api_choice": {
+    "mechanism_level":          "syntactic_ast | control_flow | path_sensitive | interprocedural_dataflow",
+    "callback":                 "check::PreCall | check::PostCall | check::PreStmt | check::PostStmt | check::Bind | check::DeadSymbols | check::EndFunction | ...",
+    "reasoning":                "Why this callback and its AST/state/CFG evidence prove the report and safe conditions",
+    "alternatives_considered":  ["check::PostCall"]
+  },
+  "implementation": {
+    "scope_level":    "patch_specific | project_general | cross_project",
+    "checker_name":   "project.CheckerName",
+    "build_attempts": 1
+  }
+}
+```
+
+### ``summary.json``
+
+```json
+{
+  "status":           "plausible | failed",
+  "bug_pattern":      "One sentence describing the bug pattern",
+  "scope_level":      "patch_specific | project_general | cross_project",
+  "checker_cpp":      "checker.cpp",
+  "checker_so":       "checker.so",
+  "n_buggy":          0,
+  "n_patched":        0,
+  "total_reports":    0,
+  "fp_rate_estimate": 0.0,
+  "failure_reason":   null
+}
+```
+
+## Feedback-derived requirements for this fresh synthesis
+
+A prior independent rollout exposed the risks below. Start again from the patch
+in this new session. Do not reconstruct, edit, or assume the prior checker.
+
+Required mechanism level: `syntax_only`
+
+### Current failure diagnosis
+
+- Only process_score failed (79.35 below threshold). hard_validation, objective_gate G6, refinement_accepted, semantic_mechanism, semantic_score, anchor_free, and hardcoding_free already passed.
+- Validation-and-recovery scored 7/10 because two synthetic analyzer repros never recovered: one called undeclared min(); the other broke parsing a hand-rolled min/__careful_cmp/__builtin_choose_expr expansion.
+- Plan-to-code consistency scored 9/12: on B = B * P the multiplier extractor can bind the reused divisor VarDecl instead of the recorded quotient.
+- CSA implementation quality marked has_report_logic false (EmitBasicReport without a BugType member or dedicated report helper), costing 0.5/4.
+- Eight fix cycles were consumed recovering compile failures (deprecated StringRef::startswith, undeclared ExprStmt), inflating process cost after checker.so already built.
+
+### Preserve from prior rollouts
+
+- Preserve successful compile, before/after validation, and code verification.
+- Preserve objective eligibility gate G6.
+- Preserve an accepted or clean refinement outcome.
+- Preserve the previously adequate syntax_only CSA mechanism (same-function AST pattern match of the patched arithmetic; no ProgramState or interprocedural machinery).
+- Preserve semantic score at or above the configured threshold.
+- Do not introduce patch-anchor dependence.
+- Do not introduce patch-local hardcoding.
+
+### Required semantic proof
+
+- Prove an unsigned same-function idiom P = A / B followed by self-multiply B *= P or B = B * P where dividend A is not statically bounded below the GSO_BY_FRAGS sentinel 0xFFFF, so B * P can wrap to that forbidden value.
+- Treat a min-style cap of A whose subtree evaluates to GSO_BY_FRAGS-1 (65534 / 0xFFFE) as the safe form that keeps B * P <= 65534.
+- The intended true positive is skb_segment GSO-partial arithmetic: uncapped len/mss folded back into mss; the patched min(len, GSO_BY_FRAGS-1)/mss form must be silent.
+- The diagnostic must be raised at the self-multiply sink, not at the division.
+
+### Implementation constraints
+
+- Implement Checker<check::ASTCodeBody> (or equivalent one-pass function-body AST walk) that records unsigned division assignments then matches a later self-multiply of the same divisor by that quotient.
+- Register a BugType and emit through BugReporter at the multiply statement so report logic is structurally present.
+- Recognize Linux min-family AST (ChooseExpr, StmtExpr, ConditionalOperator, min/min_t/clamp-style calls) plus a constant 65534 as the project GSO cap, not as a file- or hunk-local token.
+- Match only unsigned integer VarDecl pairs inside one function body; do not key off skb_segment, net/core/skbuff.c, CVE ids, or changed line numbers.
+- Use current LLVM/Clang APIs and real Stmt/Expr nodes only.
+- When the multiply RHS is BO_Mul, the matched multiplier must be the recorded quotient VarDecl, never the LHS divisor.
+
+### Validation checklist
+
+- Fresh sources compile to a loadable checker.so with zero compiler diagnostics.
+- Pre-patch scan of net/core/skbuff.c::skb_segment reports at mss *= partial_segs (median distance about 1 line from the patched arithmetic).
+- Post-patch scan is clean on min(len, GSO_BY_FRAGS-1)/mss (n_patched=0, patched_clean).
+- Differential: relevant warnings disappear only inside skb_segment; unrelated disappearances stay 0; sparsity/relevance remain 1.0.
+- Cross-validation stays VALID and refinement stays accepted or clean.
+- If a standalone repro is used, it must compile with a min() that actually produces a capping AST containing 65534, and any analyzer failure must be recovered.
+- Re-score process_score above threshold without dropping G6 or semantic_score.
+
+### Avoid and forbidden regressions
+
+- Do not edit, clone, resume, or reconstruct the prior MssOverflowChecker/BodyWalker.
+- Do not finish with unrecovered synthetic repros that cannot compile or cannot expand min().
+- Do not call StringRef::startswith or dyn_cast to ExprStmt.
+- Do not treat either operand of B = B * P as interchangeable.
+- Do not use path-sensitive SVal tracking of mss*partial_segs or a PreStmt-only callback that cannot see the earlier division.
+- Do not encode the patch hunk, source path, or function name as the match key.
+- Do not omit a BugType/report helper.
+- Do not burn repeated compile-fix cycles on deprecated or non-existent AST APIs.

tasks/csa159/pair_164279/checker_template.cpp

@@ -0,0 +1,98 @@
+// ============================================================================
+// CSA Checker Template
+// ============================================================================
+// Fill in the sections marked with TODO to implement your checker.
+// The checker is compiled with -fno-rtti to match the LLVM 18 build config.
+// It is loaded via: clang -cc1 -load checker.so -analyzer-checker=your.CheckerName
+//
+// Compilation:
+//   clang++ -std=c++17 -fPIC -shared -fno-rtti -fno-exceptions \
+//           -I${LLVM_BUILD_DIR}/include \
+//           checker.cpp -o checker.so \
+//           -Wl,--allow-shlib-undefined
+//
+// Usage:
+//   clang -cc1 -load ./checker.so -analyzer-checker=your.CheckerName -analyze <file>
+// ============================================================================
+
+#include "clang/StaticAnalyzer/Core/BugReporter/BugReporter.h"
+#include "clang/StaticAnalyzer/Core/BugReporter/BugType.h"
+#include "clang/StaticAnalyzer/Core/Checker.h"
+#include "clang/StaticAnalyzer/Core/PathSensitive/CallEvent.h"
+#include "clang/StaticAnalyzer/Core/PathSensitive/CheckerContext.h"
+#include "clang/StaticAnalyzer/Frontend/CheckerRegistry.h"
+
+using namespace clang;
+using namespace ento;
+
+namespace {
+
+// ────────────────────────────────────────────────────────────────
+// TODO: Rename this class to describe your checker's purpose.
+// ────────────────────────────────────────────────────────────────
+class {{CHECKER_CLASS_NAME}}
+    : public Checker<check::PreCall,      // for checking before function calls
+                     check::PostCall>     // for checking after function calls
+{
+  // TODO: Customize the bug type name and category.
+  mutable std::unique_ptr<BugType> BT;
+
+public:
+  {{CHECKER_CLASS_NAME}}()
+      : BT(new BugType(this, "{{BUG_NAME}}", "{{BUG_CATEGORY}}")) {}
+
+  // ── PreCall callback (fires before every function call) ──────
+  void checkPreCall(const CallEvent &Call, CheckerContext &C) const {
+    // TODO: Implement your pre-call analysis logic here.
+    //
+    // Common patterns:
+    //
+    // 1. Check if the called function matches a specific name:
+    //    if (Call.getCalleeIdentifier()) {
+    //      StringRef name = Call.getCalleeIdentifier()->getName();
+    //      if (name == "target_function") { ... }
+    //    }
+    //
+    // 2. Get the program state:
+    //    ProgramStateRef State = C.getState();
+    //
+    // 3. Get arguments:
+    //    SVal Arg = Call.getArgSVal(0);
+    //
+    // 4. Generate a bug report:
+    //    ExplodedNode *ErrNode = C.generateErrorNode();
+    //    if (ErrNode) {
+    //      auto R = std::make_unique<PathSensitiveBugReport>(
+    //          *BT, "Description of the bug", ErrNode);
+    //      C.emitReport(std::move(R));
+    //    }
+  }
+
+  // ── PostCall callback (fires after every function call) ─────
+  void checkPostCall(const CallEvent &Call, CheckerContext &C) const {
+    // TODO: Implement your post-call analysis logic here.
+    //
+    // Common pattern — check the return value:
+    //   SVal RetVal = Call.getReturnValue();
+    //   if (RetVal.isUnknownOrUndef()) return;
+    //
+    //   ProgramStateRef State = C.getState();
+    //   // Modify state based on post-call conditions...
+  }
+};
+
+} // anonymous namespace
+
+// ────────────────────────────────────────────────────────────────
+// Registration — DO NOT modify the function signatures.
+// ────────────────────────────────────────────────────────────────
+
+extern "C" void clang_registerCheckers(CheckerRegistry &registry) {
+  registry.addChecker<{{CHECKER_CLASS_NAME}}>(
+      "{{CHECKER_FULL_NAME}}",  // e.g., "your.NullDereferenceChecker"
+      "{{CHECKER_DESC}}",       // e.g., "Detects null pointer dereference"
+      "{{CHECKER_DOC_URI}}");   // e.g., "https://example.com/docs"
+}
+
+extern "C" const char clang_analyzerAPIVersionString[] =
+    CLANG_ANALYZER_API_VERSION_STRING;

tasks/csa159/pair_164279/config.json

@@ -0,0 +1,19 @@
+{
+  "project_id": "torvalds_linux",
+  "before_commit": "6da6680632792709cecf2b006f2fe3ca7857e791",
+  "after_commit": "d0aac2363549e12cc79b8e285f13d5a9f42fd08e",
+  "repo_path": "/workspace/repo/torvalds/linux",
+  "llvm_build_dir": "/opt/llvm",
+  "before_compile_commands": "/workspace/benchmark/data-pipeline/snapshots/torvalds_linux/a38297e3fb012ddfa7ce0321a7e5a8daeb1872b6/compile_commands.json",
+  "after_compile_commands": "/workspace/benchmark/data-pipeline/snapshots/torvalds_linux/a38297e3fb012ddfa7ce0321a7e5a8daeb1872b6/compile_commands.json",
+  "changed_files": [
+    "block/blk-cgroup.c"
+  ],
+  "commit_message": "blk-cgroup: fix list corruption from reorder of WRITE ->lqueued\n\n__blkcg_rstat_flush() can be run anytime, especially when blk_cgroup_bio_start\nis being executed.\n\nIf WRITE of `->lqueued` is re-ordered with READ of 'bisc->lnode.next' in\nthe loop of __blkcg_rstat_flush(), `next_bisc` can be assigned with one\nstat instance being added in blk_cgroup_bio_start(), then the local\nlist in __blkcg_rstat_flush() could be corrupted.\n\nFix the issue by adding one barrier.\n\nCc: Tejun Heo <tj@kernel.org>\nCc: Waiman Long <longman@redhat.com>\nFixes: 3b8cc6298724 (\"blk-cgroup: Optimize blkcg_rstat_flush()\")\nSigned-off-by: Ming Lei <ming.lei@redhat.com>\nLink: https://lore.kernel.org/r/20240515013157.443672-3-ming.lei@redhat.com\nSigned-off-by: Jens Axboe <axboe@kernel.dk>",
+  "t_valid": 50,
+  "t_plausible": 20,
+  "triage_sample_size": 10,
+  "max_synthesis_retry": 0,
+  "max_in_session_redesigns": 1,
+  "max_refinement_iter": 3
+}

tasks/csa159/pair_164279/patch.diff

@@ -0,0 +1,21 @@
+diff --git a/block/blk-cgroup.c b/block/blk-cgroup.c
+index 8699f193cf31..52367a4501d0 100644
+--- a/block/blk-cgroup.c
++++ b/block/blk-cgroup.c
+@@ -1035,6 +1035,16 @@ static void __blkcg_rstat_flush(struct blkcg *blkcg, int cpu)
+ 		struct blkg_iostat cur;
+ 		unsigned int seq;
+ 
++		/*
++		 * Order assignment of `next_bisc` from `bisc->lnode.next` in
++		 * llist_for_each_entry_safe and clearing `bisc->lqueued` for
++		 * avoiding to assign `next_bisc` with new next pointer added
++		 * in blk_cgroup_bio_start() in case of re-ordering.
++		 *
++		 * The pair barrier is implied in llist_add() in blk_cgroup_bio_start().
++		 */
++		smp_mb();
++
+ 		WRITE_ONCE(bisc->lqueued, false);
+ 
+ 		/* fetch the current per-cpu values */

tasks/csa159/pair_164279/post_functions.txt

@@ -0,0 +1,62 @@
+### File: block/blk-cgroup.c
+```c
+static void __blkcg_rstat_flush(struct blkcg *blkcg, int cpu)
+{
+	struct llist_head *lhead = per_cpu_ptr(blkcg->lhead, cpu);
+	struct llist_node *lnode;
+	struct blkg_iostat_set *bisc, *next_bisc;
+	unsigned long flags;
+
+	rcu_read_lock();
+
+	lnode = llist_del_all(lhead);
+	if (!lnode)
+		goto out;
+
+	/*
+	 * For covering concurrent parent blkg update from blkg_release().
+	 *
+	 * When flushing from cgroup, cgroup_rstat_lock is always held, so
+	 * this lock won't cause contention most of time.
+	 */
+	raw_spin_lock_irqsave(&blkg_stat_lock, flags);
+
+	/*
+	 * Iterate only the iostat_cpu's queued in the lockless list.
+	 */
+	llist_for_each_entry_safe(bisc, next_bisc, lnode, lnode) {
+		struct blkcg_gq *blkg = bisc->blkg;
+		struct blkcg_gq *parent = blkg->parent;
+		struct blkg_iostat cur;
+		unsigned int seq;
+
+		/*
+		 * Order assignment of `next_bisc` from `bisc->lnode.next` in
+		 * llist_for_each_entry_safe and clearing `bisc->lqueued` for
+		 * avoiding to assign `next_bisc` with new next pointer added
+		 * in blk_cgroup_bio_start() in case of re-ordering.
+		 *
+		 * The pair barrier is implied in llist_add() in blk_cgroup_bio_start().
+		 */
+		smp_mb();
+
+		WRITE_ONCE(bisc->lqueued, false);
+
+		/* fetch the current per-cpu values */
+		do {
+			seq = u64_stats_fetch_begin(&bisc->sync);
+			blkg_iostat_set(&cur, &bisc->cur);
+		} while (u64_stats_fetch_retry(&bisc->sync, seq));
+
+		blkcg_iostat_update(blkg, &cur, &bisc->last);
+
+		/* propagate global delta to parent (unless that's root) */
+		if (parent && parent->parent)
+			blkcg_iostat_update(parent, &blkg->iostat.cur,
+					    &blkg->iostat.last);
+	}
+	raw_spin_unlock_irqrestore(&blkg_stat_lock, flags);
+out:
+	rcu_read_unlock();
+}
+```

tasks/csa159/pair_164279/pre_functions.txt

@@ -0,0 +1,52 @@
+### File: block/blk-cgroup.c
+```c
+static void __blkcg_rstat_flush(struct blkcg *blkcg, int cpu)
+{
+	struct llist_head *lhead = per_cpu_ptr(blkcg->lhead, cpu);
+	struct llist_node *lnode;
+	struct blkg_iostat_set *bisc, *next_bisc;
+	unsigned long flags;
+
+	rcu_read_lock();
+
+	lnode = llist_del_all(lhead);
+	if (!lnode)
+		goto out;
+
+	/*
+	 * For covering concurrent parent blkg update from blkg_release().
+	 *
+	 * When flushing from cgroup, cgroup_rstat_lock is always held, so
+	 * this lock won't cause contention most of time.
+	 */
+	raw_spin_lock_irqsave(&blkg_stat_lock, flags);
+
+	/*
+	 * Iterate only the iostat_cpu's queued in the lockless list.
+	 */
+	llist_for_each_entry_safe(bisc, next_bisc, lnode, lnode) {
+		struct blkcg_gq *blkg = bisc->blkg;
+		struct blkcg_gq *parent = blkg->parent;
+		struct blkg_iostat cur;
+		unsigned int seq;
+
+		WRITE_ONCE(bisc->lqueued, false);
+
+		/* fetch the current per-cpu values */
+		do {
+			seq = u64_stats_fetch_begin(&bisc->sync);
+			blkg_iostat_set(&cur, &bisc->cur);
+		} while (u64_stats_fetch_retry(&bisc->sync, seq));
+
+		blkcg_iostat_update(blkg, &cur, &bisc->last);
+
+		/* propagate global delta to parent (unless that's root) */
+		if (parent && parent->parent)
+			blkcg_iostat_update(parent, &blkg->iostat.cur,
+					    &blkg->iostat.last);
+	}
+	raw_spin_unlock_irqrestore(&blkg_stat_lock, flags);
+out:
+	rcu_read_unlock();
+}
+```

tasks/csa159/pair_164279/task_prompt.md

@@ -0,0 +1,318 @@
+# Task: Synthesize a CSA Checker from a CVE Patch
+
+## Your Role
+
+You are a static analysis expert. Synthesize a Clang Static Analyzer (CSA) checker
+that detects the bug pattern fixed by the CVE patch in this working directory.
+
+You have full filesystem and bash access — use them.
+
+### Skills
+
+Many skills are available under `.claude/skills/` — covering vulnerability analysis,
+checker design, debugging, code audit, security patterns, and more.  Each skill
+encodes reusable expertise: take time to explore them, read their SKILL.md files,
+and invoke those that look useful via the Skill tool.  Let the task guide which
+ones you reach for.
+
+## File Layout
+
+```
+/work/
+├── compile.sh               ← RUN ME: compile checker.cpp → checker.so
+├── checker_template.cpp     ← skeleton, start here
+├── patch.diff               ← the CVE fix
+├── pre_functions.txt        ← buggy source (before_commit)
+├── post_functions.txt       ← patched source (after_commit)
+├── config.json              ← paths, commit_message, commit hashes, flags
+├── scan/
+│   ├── scan_before.sh       ← RUN ME: scan before_commit → N_buggy
+│   ├── scan_after.sh        ← RUN ME: scan after_commit → N_patched
+│   └── flags_*.txt          ← pre-extracted compile flags (-I, -D)
+├── references/
+│   ├── repo_knowledge.md            ← project-specific API/convention reference
+│   ├── patterns_summary.md       ← (optional) historical bug pattern summary
+│   ├── cwe_cards/                ← CWE knowledge library (all categories)
+│   │   ├── index.json             ← lookup index — use to find relevant cards
+│   │   ├── CWE-{id}(-variant).md  ← Tier 1/2 per-CWE detection patterns
+│   │   ├── Category-{name}.md     ← Tier 3 umbrella cards (rare CWEs grouped)
+│   ├── csa_headers_api.md   ← API quick reference (extracted from LLVM 18 headers)
+│   ├── csa_checker_patterns.md ← pattern catalog (resource tracking, null check, etc.)
+│   ├── csa_utility_functions.h ← copy-paste C++ helpers for checker.cpp (AST traversal, expression eval, etc.)
+│   └── examples/
+│       └── llvm-official/   ← 5 official checker sources (with comments)
+│           ├── 01_div_zero.cpp
+│           ├── 02_simple_stream.cpp
+│           ├── 03_undef_result.cpp
+│           ├── 04_nullability.cpp
+│           └── 05_malloc.cpp
+│
+├── checker.cpp              ← YOUR OUTPUT: synthesized checker
+├── checker.so               ← YOUR OUTPUT: compiled checker
+├── state.json               ← YOUR OUTPUT: structured task state
+├── scope_statement.md       ← YOUR OUTPUT: checker scope analysis (Level 1/2/3)
+└── summary.json             ← YOUR OUTPUT: final report
+```
+
+## Resources
+
+**Read these before writing any code:**
+
+1. **`references/csa_headers_api.md`** — CSA API quick reference. Extracted directly from
+   LLVM 18 headers. Covers all checker callbacks, ProgramState operations, SVal types,
+   MemRegion hierarchy, and bug reporting. **Read this first whenever you need API info.**
+
+2. **`references/csa_checker_patterns.md`** — Pattern catalog. Documents 5 battle-tested
+   patterns from official LLVM checkers: resource tracking, null checking, undefined
+   value detection, division-by-zero, and malloc/free. Each pattern includes skeleton
+   code, state traits, and key API usage.
+
+3. **`references/examples/llvm-official/`** — 5 official LLVM 18 checker implementations
+   with explanatory comments:
+   - `01_div_zero.cpp` — simplest checker (169 lines, 1 callback)
+   - `02_simple_stream.cpp` — resource tracking (292 lines, fopen/fclose)
+   - `03_undef_result.cpp` — PostStmt pattern (160 lines)
+   - `04_nullability.cpp` — multi-callback checker (1247 lines)
+   - `05_malloc.cpp` — comprehensive malloc/free (1511 lines)
+
+4. **`checker_template.cpp`** — Skeleton with placeholders. Start here.
+
+5. **`references/repo_knowledge.md`** — Project-specific reference. Contains this
+   repository's memory allocation API, key data types, source layout, and typical
+   CVE patterns. **Read this before writing the checker** — knowing the project's
+   alloc/free conventions and common bug patterns saves many grep rounds.
+
+5b. **`references/patterns_summary.md`** — (may not exist) Historical synthesis
+   patterns for this project.  If present, it contains a concise summary of the
+   most common bug patterns, frequent CWE categories, and reusable checker
+   architectures observed in previous synthesis runs.  Read after repo_knowledge.md.
+
+6. **`references/cwe_cards/`** — Complete CWE knowledge base covering all
+   vulnerability categories.  **The framework provides the full library —
+   you must identify the vulnerability type yourself.**  Workflow:
+
+   1. Analyse the patch diff and commit message to determine the vulnerability
+      type (buffer overflow, UAF, null deref, integer overflow, race condition,
+      etc.).  Do NOT rely on the CWE label — treat it as a hint at most.
+   2. Open ``index.json`` to discover available cards and their tiers.
+   3. Read the relevant card(s) for **detection strategies**, **checker
+      architecture suggestions**, and **known false-positive patterns**.
+
+   Card tiers:
+   - ``CWE-{id}(-{variant}).md`` — Tier 1/2 cards for common CWEs; kernel /
+     userspace variants when the detection strategy differs substantially.
+   - ``Category-{name}.md`` — Tier 3 umbrella cards grouping rarer CWEs by
+     category (input validation, resource management, etc.).
+
+7. **`references/csa_utility_functions.h`** — Copy-paste C++ helper functions for
+   checker.cpp. Includes AST traversal (`findSpecificTypeInParents/Children`),
+   expression evaluation (`EvaluateExprToInt`, `inferSymbolMaxVal`), array/string
+   size extraction, MemRegion helpers, and `ExprHasName()` for robust function
+   matching. All verified against LLVM 18. **Read before implementing detection
+   logic** — these save writing boilerplate that's easy to get wrong.
+
+## Environment
+
+Key paths are in ``config.json``.
+
+### Pre-built scripts
+
+| Script | What it does |
+|--------|-------------|
+| `bash compile.sh` | Compile checker.cpp → checker.so (with correct flags) |
+| `CHECKER_NAME=<name> bash scan/scan_before.sh` | Scan before_commit, count warnings → N_buggy |
+| `CHECKER_NAME=<name> bash scan/scan_after.sh` | Scan after_commit, count warnings → N_patched |
+
+```bash
+# Compile (run from workdir root)
+bash compile.sh
+
+# Scan — set CHECKER_NAME to the string passed to addChecker<>()
+CHECKER_NAME=your.CheckerName bash scan/scan_before.sh   # → N_buggy
+CHECKER_NAME=your.CheckerName bash scan/scan_after.sh    # → N_patched
+```
+
+- ``compile.sh`` already has the correct ``-I`` / ``-fno-rtti`` flags.
+- ``scan/scan_*.sh`` count only warnings tagged with your checker name.
+- Scan environments (source files + compile flags) are pre-built in ``scan/``.
+
+### Scan Script Integrity (CRITICAL)
+
+The scan scripts (``scan/scan_before.sh``, ``scan/scan_after.sh``) are the **only
+valid measurement** of N_buggy and N_patched.  They are the ground truth that the
+Python-side validator will also use.  You MUST obey these rules:
+
+**1. Never bypass the scan scripts.**  Do NOT run ``clang --analyze`` directly
+   to measure warning counts.  The Python validator runs the same scan scripts
+   — if you measured with a different command, your numbers will not reproduce
+   and the synthesis will be rejected.
+
+**2. If the scan script prints COMPILE_ERROR** (missing headers, undeclared
+   identifiers, etc.), the scan environment needs repair.  You MUST fix it:
+   - Add missing ``-I`` include paths to the flags files in ``scan/``
+   - Copy needed generated headers (e.g. ``autoconf.h``) from the snapshot
+   - If the file fundamentally cannot be compiled by clang, stop and write
+     ``summary.json`` with ``status: "failed"`` and an honest ``failure_reason``
+
+**3. Only trust scan script output.**  The ``Total <name> warnings: N`` line
+   printed by the scan script is the number that goes into ``summary.json``.
+   If the scan script says 0, write 0.  Fabricating numbers that the scan
+   script did not produce will cause the Python validator to reject the
+   synthesis.
+
+- If compile fails: read the error, fix ``checker.cpp``, retry (max 3 cycles).
+- If validation fails: revise checker logic, re-compile, re-scan.
+
+## MCP Tools
+
+You have access to 3 MCP tools under the `csa-tools` server (prefixed `mcp__csa-tools__`).
+Each returns **source context embedded in the result** — no need to follow up with Read.
+
+| Tool | What it does | Key advantage |
+|------|-------------|---------------|
+| `search(pattern, scope)` | Search for a pattern in source / LLVM headers / workdir | Returns file:line + 3 lines context — grep + Read in one call |
+| `compile()` | Run compile.sh, return parsed diagnostics | Errors include checker.cpp context — fix without reading the file |
+| `scan(checker_name)` | Run before/after scan, return N_buggy + N_patched + warning locations | Each warning includes source context — no manual clang --analyze needed |
+
+### When to use each
+
+- **`search`**: Whenever you would type `grep -rn "X"` or `find ... -name`. Use `scope="source"` for CVE code, `scope="llvm"` for CSA API headers, `scope="all"` when unsure.
+- **`compile`**: Instead of `bash compile.sh` followed by reading checker.cpp at error lines.
+- **`scan`**: Instead of running scan_before.sh + scan_after.sh + manual clang inspection. Returns everything you need to decide next action.
+
+## Semantic Design Contract — before writing checker.cpp
+
+Create the analysis portions of `state.json` and `scope_statement.md` **before**
+writing checker.cpp. They are a design contract, not a retrospective summary.
+After compilation, update only implementation facts such as `build_attempts`.
+
+In `patch_analysis`, distinguish the vulnerable operation, its trigger, and the
+semantic fact introduced by the patch that makes it safe. In `detection_plan`,
+make `report_condition`, `safe_condition`, and `source_level_signal` concrete
+CSA-observable facts. In `api_choice`, record the mechanism level and explain
+why the selected callback can observe and prove those facts.
+
+In `scope_statement.md`, include this mapping table and check it again after
+implementation:
+
+| Semantic condition | CSA evidence | checker.cpp implementation |
+| --- | --- | --- |
+| report condition | AST / SVal / MemRegion / CFG evidence | callback, helper, and branch that reports |
+| safe condition | path constraint, guard, state discharge, or structural fact | branch that suppresses the report |
+
+Every condition in the plan must have an implementation entry. Do not claim a
+condition that checker.cpp does not implement, and do not silently add a code
+condition absent from the plan.
+
+## Mechanism Selection — diagnose before coding
+
+Choose the weakest CSA mechanism that can prove the vulnerability property:
+
+1. **syntax-only AST**: only when local AST shape itself is the defect;
+2. **control flow / dominance**: when guard placement relative to a sink matters;
+3. **path-sensitive ProgramState/SVal**: when an unsafe state must reach a use;
+4. **cross-procedure/dataflow**: when the required fact crosses function boundaries.
+
+For a guard-based patch, prove both that the guard rejects the unsafe value and
+that it dominates the vulnerable use. For path-sensitive or cross-procedure
+defects, do not replace the required state or flow proof with local AST matching
+or source-text substring matching merely because it passes the differential scan.
+Record the selected level as `api_choice.mechanism_level`.
+
+## Semantic identity, locality, and final validation
+
+Before accepting the checker, verify that its primary matching logic does not
+depend on patch-local variable names, labels, line numbers, commit IDs, or unique
+literals. Project APIs, types, and stable semantic call relationships are valid
+scope anchors when they define the vulnerability class. Attach the report to the
+actual vulnerable operation, and implement every suppression as a real safe
+condition rather than the mere presence of a nearby guard-shaped statement.
+
+The required final sequence is: **compile → before scan → after scan → inspect
+the final checker name, artifacts, and report locations → write summary.json**.
+Always run the final compile and both scans. `MAX_IN_SESSION_REDESIGNS` limits only
+additional redesign cycles after a failed validation; if it is zero, preserve the
+real validation evidence and report failure honestly rather than fabricating counts.
+
+## Validation Criteria
+
+```
+VALID   : N_buggy > N_patched  AND  N_patched < 50
+INVALID : otherwise → revise and re-validate (max 1 attempts)
+```
+
+## Refinement
+
+Do NOT self-refine the checker repeatedly. Your goal is to produce the first
+checker that passes the Validation Criteria above — fix compile errors and
+validation failures only. False positives are triaged and repaired by the
+framework's refinement stage: you will receive a concrete FP list via
+session resume (if needed) and fix only those. Reserve budget for that stage.
+
+## Output
+
+Produce all of the following **only when completely done**:
+
+| File | Content |
+|------|---------|
+| ``checker.cpp`` | Synthesized checker source code |
+| ``checker.so`` | Compiled checker plugin |
+| ``state.json`` | Structured task state (see schema below) |
+| ``scope_statement.md`` | Checker scope analysis in prose (Level 1/2/3) |
+| ``summary.json`` | Final report (see schema below) |
+
+Writing ``summary.json`` signals completion.  Do NOT write it early.
+
+### ``state.json``
+
+Create this before writing checker.cpp to capture the design contract. After the
+checker compiles, update only implementation facts and retain the original
+semantic plan.
+
+```json
+{
+  "patch_analysis": {
+    "summary":           "One sentence describing the vulnerability this patch fixes",
+    "changed_files":     ["file1.c", "file2.h"],
+    "changed_functions": ["func_a", "func_b"],
+    "bug_type":          "buffer_overflow | use_after_free | null_deref | integer_overflow | race_condition | resource_leak | double_free | input_validation | other",
+    "fix_strategy":      "add_bounds_check | add_null_check | add_size_check | add_early_return | reorder_operations | change_api_signature | other",
+    "affected_types":    ["GF_BitStream", "custom_struct_t"],
+    "critical_calls":    ["gf_strdup", "memcpy"]
+  },
+  "detection_plan": {
+    "bug_pattern":         "High-level description of the vulnerability pattern (e.g. 'heap buffer overflow when reading variable-length data into a fixed-size stack buffer without size bound')",
+    "report_condition":    "When should the checker emit a warning? (e.g. 'call to gf_strdup where the argument originates from a fixed-size local array that was populated by variable-length bitstream reads')",
+    "safe_condition":      "When should the checker NOT emit a warning? (e.g. 'argument originates from a heap allocation or a size-bounded source')",
+    "source_level_signal": "What AST / MemRegion / SVal property does the checker look for? (e.g. 'MemRegion extent < parameter size at a PreCall to gf_strdup')"
+  },
+  "api_choice": {
+    "mechanism_level":          "syntactic_ast | control_flow | path_sensitive | interprocedural_dataflow",
+    "callback":                 "check::PreCall | check::PostCall | check::PreStmt | check::PostStmt | check::Bind | check::DeadSymbols | check::EndFunction | ...",
+    "reasoning":                "Why this callback and its AST/state/CFG evidence prove the report and safe conditions",
+    "alternatives_considered":  ["check::PostCall"]
+  },
+  "implementation": {
+    "scope_level":    "patch_specific | project_general | cross_project",
+    "checker_name":   "project.CheckerName",
+    "build_attempts": 1
+  }
+}
+```
+
+### ``summary.json``
+
+```json
+{
+  "status":           "plausible | failed",
+  "bug_pattern":      "One sentence describing the bug pattern",
+  "scope_level":      "patch_specific | project_general | cross_project",
+  "checker_cpp":      "checker.cpp",
+  "checker_so":       "checker.so",
+  "n_buggy":          0,
+  "n_patched":        0,
+  "total_reports":    0,
+  "fp_rate_estimate": 0.0,
+  "failure_reason":   null
+}
+```

tasks/csa159/pair_164624/checker_template.cpp

@@ -0,0 +1,98 @@
+// ============================================================================
+// CSA Checker Template
+// ============================================================================
+// Fill in the sections marked with TODO to implement your checker.
+// The checker is compiled with -fno-rtti to match the LLVM 18 build config.
+// It is loaded via: clang -cc1 -load checker.so -analyzer-checker=your.CheckerName
+//
+// Compilation:
+//   clang++ -std=c++17 -fPIC -shared -fno-rtti -fno-exceptions \
+//           -I${LLVM_BUILD_DIR}/include \
+//           checker.cpp -o checker.so \
+//           -Wl,--allow-shlib-undefined
+//
+// Usage:
+//   clang -cc1 -load ./checker.so -analyzer-checker=your.CheckerName -analyze <file>
+// ============================================================================
+
+#include "clang/StaticAnalyzer/Core/BugReporter/BugReporter.h"
+#include "clang/StaticAnalyzer/Core/BugReporter/BugType.h"
+#include "clang/StaticAnalyzer/Core/Checker.h"
+#include "clang/StaticAnalyzer/Core/PathSensitive/CallEvent.h"
+#include "clang/StaticAnalyzer/Core/PathSensitive/CheckerContext.h"
+#include "clang/StaticAnalyzer/Frontend/CheckerRegistry.h"
+
+using namespace clang;
+using namespace ento;
+
+namespace {
+
+// ────────────────────────────────────────────────────────────────
+// TODO: Rename this class to describe your checker's purpose.
+// ────────────────────────────────────────────────────────────────
+class {{CHECKER_CLASS_NAME}}
+    : public Checker<check::PreCall,      // for checking before function calls
+                     check::PostCall>     // for checking after function calls
+{
+  // TODO: Customize the bug type name and category.
+  mutable std::unique_ptr<BugType> BT;
+
+public:
+  {{CHECKER_CLASS_NAME}}()
+      : BT(new BugType(this, "{{BUG_NAME}}", "{{BUG_CATEGORY}}")) {}
+
+  // ── PreCall callback (fires before every function call) ──────
+  void checkPreCall(const CallEvent &Call, CheckerContext &C) const {
+    // TODO: Implement your pre-call analysis logic here.
+    //
+    // Common patterns:
+    //
+    // 1. Check if the called function matches a specific name:
+    //    if (Call.getCalleeIdentifier()) {
+    //      StringRef name = Call.getCalleeIdentifier()->getName();
+    //      if (name == "target_function") { ... }
+    //    }
+    //
+    // 2. Get the program state:
+    //    ProgramStateRef State = C.getState();
+    //
+    // 3. Get arguments:
+    //    SVal Arg = Call.getArgSVal(0);
+    //
+    // 4. Generate a bug report:
+    //    ExplodedNode *ErrNode = C.generateErrorNode();
+    //    if (ErrNode) {
+    //      auto R = std::make_unique<PathSensitiveBugReport>(
+    //          *BT, "Description of the bug", ErrNode);
+    //      C.emitReport(std::move(R));
+    //    }
+  }
+
+  // ── PostCall callback (fires after every function call) ─────
+  void checkPostCall(const CallEvent &Call, CheckerContext &C) const {
+    // TODO: Implement your post-call analysis logic here.
+    //
+    // Common pattern — check the return value:
+    //   SVal RetVal = Call.getReturnValue();
+    //   if (RetVal.isUnknownOrUndef()) return;
+    //
+    //   ProgramStateRef State = C.getState();
+    //   // Modify state based on post-call conditions...
+  }
+};
+
+} // anonymous namespace
+
+// ────────────────────────────────────────────────────────────────
+// Registration — DO NOT modify the function signatures.
+// ────────────────────────────────────────────────────────────────
+
+extern "C" void clang_registerCheckers(CheckerRegistry &registry) {
+  registry.addChecker<{{CHECKER_CLASS_NAME}}>(
+      "{{CHECKER_FULL_NAME}}",  // e.g., "your.NullDereferenceChecker"
+      "{{CHECKER_DESC}}",       // e.g., "Detects null pointer dereference"
+      "{{CHECKER_DOC_URI}}");   // e.g., "https://example.com/docs"
+}
+
+extern "C" const char clang_analyzerAPIVersionString[] =
+    CLANG_ANALYZER_API_VERSION_STRING;

tasks/csa159/pair_164624/config.json

@@ -0,0 +1,19 @@
+{
+  "project_id": "torvalds_linux",
+  "before_commit": "8adc718881e0a70127f8843dd70e69a80de39352",
+  "after_commit": "78a033433a5ae4fee85511ee075bc9a48312c79e",
+  "repo_path": "/workspace/repo/torvalds/linux",
+  "llvm_build_dir": "/opt/llvm",
+  "before_compile_commands": "/workspace/benchmark/data-pipeline/snapshots/torvalds_linux/f0e2f00c49db0cba1feff7ce5a5f163d2152056f/compile_commands.json",
+  "after_compile_commands": "/workspace/benchmark/data-pipeline/snapshots/torvalds_linux/f0e2f00c49db0cba1feff7ce5a5f163d2152056f/compile_commands.json",
+  "changed_files": [
+    "drivers/gpu/drm/i915/gt/intel_engine_cs.c"
+  ],
+  "commit_message": "drm/i915/gt: Cleanup partial engine discovery failures\n\nIf we abort driver initialisation in the middle of gt/engine discovery,\nsome engines will be fully setup and some not. Those incompletely setup\nengines only have 'engine->release == NULL' and so will leak any of the\ncommon objects allocated.\n\nv2:\n - Drop the destroy_pinned_context() helper for now.  It's not really\n   worth it with just a single callsite at the moment.  (Janusz)\n\nSigned-off-by: Chris Wilson <chris.p.wilson@intel.com>\nCc: Janusz Krzysztofik <janusz.krzysztofik@linux.intel.com>\nSigned-off-by: Matt Roper <matthew.d.roper@intel.com>\nReviewed-by: Janusz Krzysztofik <janusz.krzysztofik@linux.intel.com>\nLink: https://patchwork.freedesktop.org/patch/msgid/20220915232654.3283095-2-matthew.d.roper@intel.com",
+  "t_valid": 50,
+  "t_plausible": 20,
+  "triage_sample_size": 10,
+  "max_synthesis_retry": 0,
+  "max_in_session_redesigns": 1,
+  "max_refinement_iter": 3
+}

tasks/csa159/pair_164624/patch.diff

@@ -0,0 +1,19 @@
+diff --git a/drivers/gpu/drm/i915/gt/intel_engine_cs.c b/drivers/gpu/drm/i915/gt/intel_engine_cs.c
+index 1f7188129cd1..2ddcad497fa3 100644
+--- a/drivers/gpu/drm/i915/gt/intel_engine_cs.c
++++ b/drivers/gpu/drm/i915/gt/intel_engine_cs.c
+@@ -1274,8 +1274,13 @@ int intel_engines_init(struct intel_gt *gt)
+ 			return err;
+ 
+ 		err = setup(engine);
+-		if (err)
++		if (err) {
++			intel_engine_cleanup_common(engine);
+ 			return err;
++		}
++
++		/* The backend should now be responsible for cleanup */
++		GEM_BUG_ON(engine->release == NULL);
+ 
+ 		err = engine_init_common(engine);
+ 		if (err)

tasks/csa159/pair_164624/post_functions.txt

@@ -0,0 +1,44 @@
+### File: drivers/gpu/drm/i915/gt/intel_engine_cs.c
+```c
+int intel_engines_init(struct intel_gt *gt)
+{
+	int (*setup)(struct intel_engine_cs *engine);
+	struct intel_engine_cs *engine;
+	enum intel_engine_id id;
+	int err;
+
+	if (intel_uc_uses_guc_submission(&gt->uc)) {
+		gt->submission_method = INTEL_SUBMISSION_GUC;
+		setup = intel_guc_submission_setup;
+	} else if (HAS_EXECLISTS(gt->i915)) {
+		gt->submission_method = INTEL_SUBMISSION_ELSP;
+		setup = intel_execlists_submission_setup;
+	} else {
+		gt->submission_method = INTEL_SUBMISSION_RING;
+		setup = intel_ring_submission_setup;
+	}
+
+	for_each_engine(engine, gt, id) {
+		err = engine_setup_common(engine);
+		if (err)
+			return err;
+
+		err = setup(engine);
+		if (err) {
+			intel_engine_cleanup_common(engine);
+			return err;
+		}
+
+		/* The backend should now be responsible for cleanup */
+		GEM_BUG_ON(engine->release == NULL);
+
+		err = engine_init_common(engine);
+		if (err)
+			return err;
+
+		intel_engine_add_user(engine);
+	}
+
+	return 0;
+}
+```

tasks/csa159/pair_164624/pre_functions.txt

@@ -0,0 +1,39 @@
+### File: drivers/gpu/drm/i915/gt/intel_engine_cs.c
+```c
+int intel_engines_init(struct intel_gt *gt)
+{
+	int (*setup)(struct intel_engine_cs *engine);
+	struct intel_engine_cs *engine;
+	enum intel_engine_id id;
+	int err;
+
+	if (intel_uc_uses_guc_submission(&gt->uc)) {
+		gt->submission_method = INTEL_SUBMISSION_GUC;
+		setup = intel_guc_submission_setup;
+	} else if (HAS_EXECLISTS(gt->i915)) {
+		gt->submission_method = INTEL_SUBMISSION_ELSP;
+		setup = intel_execlists_submission_setup;
+	} else {
+		gt->submission_method = INTEL_SUBMISSION_RING;
+		setup = intel_ring_submission_setup;
+	}
+
+	for_each_engine(engine, gt, id) {
+		err = engine_setup_common(engine);
+		if (err)
+			return err;
+
+		err = setup(engine);
+		if (err)
+			return err;
+
+		err = engine_init_common(engine);
+		if (err)
+			return err;
+
+		intel_engine_add_user(engine);
+	}
+
+	return 0;
+}
+```

tasks/csa159/pair_164624/task_prompt.md

@@ -0,0 +1,376 @@
+# Task: Synthesize a CSA Checker from a CVE Patch
+
+## Your Role
+
+You are a static analysis expert. Synthesize a Clang Static Analyzer (CSA) checker
+that detects the bug pattern fixed by the CVE patch in this working directory.
+
+You have full filesystem and bash access — use them.
+
+### Skills
+
+Many skills are available under `.claude/skills/` — covering vulnerability analysis,
+checker design, debugging, code audit, security patterns, and more.  Each skill
+encodes reusable expertise: take time to explore them, read their SKILL.md files,
+and invoke those that look useful via the Skill tool.  Let the task guide which
+ones you reach for.
+
+## File Layout
+
+```
+/work/
+├── compile.sh               ← RUN ME: compile checker.cpp → checker.so
+├── checker_template.cpp     ← skeleton, start here
+├── patch.diff               ← the CVE fix
+├── pre_functions.txt        ← buggy source (before_commit)
+├── post_functions.txt       ← patched source (after_commit)
+├── config.json              ← paths, commit_message, commit hashes, flags
+├── scan/
+│   ├── scan_before.sh       ← RUN ME: scan before_commit → N_buggy
+│   ├── scan_after.sh        ← RUN ME: scan after_commit → N_patched
+│   └── flags_*.txt          ← pre-extracted compile flags (-I, -D)
+├── references/
+│   ├── repo_knowledge.md            ← project-specific API/convention reference
+│   ├── patterns_summary.md       ← (optional) historical bug pattern summary
+│   ├── cwe_cards/                ← CWE knowledge library (all categories)
+│   │   ├── index.json             ← lookup index — use to find relevant cards
+│   │   ├── CWE-{id}(-variant).md  ← Tier 1/2 per-CWE detection patterns
+│   │   ├── Category-{name}.md     ← Tier 3 umbrella cards (rare CWEs grouped)
+│   ├── csa_headers_api.md   ← API quick reference (extracted from LLVM 18 headers)
+│   ├── csa_checker_patterns.md ← pattern catalog (resource tracking, null check, etc.)
+│   ├── csa_utility_functions.h ← copy-paste C++ helpers for checker.cpp (AST traversal, expression eval, etc.)
+│   └── examples/
+│       └── llvm-official/   ← 5 official checker sources (with comments)
+│           ├── 01_div_zero.cpp
+│           ├── 02_simple_stream.cpp
+│           ├── 03_undef_result.cpp
+│           ├── 04_nullability.cpp
+│           └── 05_malloc.cpp
+│
+├── checker.cpp              ← YOUR OUTPUT: synthesized checker
+├── checker.so               ← YOUR OUTPUT: compiled checker
+├── state.json               ← YOUR OUTPUT: structured task state
+├── scope_statement.md       ← YOUR OUTPUT: checker scope analysis (Level 1/2/3)
+└── summary.json             ← YOUR OUTPUT: final report
+```
+
+## Resources
+
+**Read these before writing any code:**
+
+1. **`references/csa_headers_api.md`** — CSA API quick reference. Extracted directly from
+   LLVM 18 headers. Covers all checker callbacks, ProgramState operations, SVal types,
+   MemRegion hierarchy, and bug reporting. **Read this first whenever you need API info.**
+
+2. **`references/csa_checker_patterns.md`** — Pattern catalog. Documents 5 battle-tested
+   patterns from official LLVM checkers: resource tracking, null checking, undefined
+   value detection, division-by-zero, and malloc/free. Each pattern includes skeleton
+   code, state traits, and key API usage.
+
+3. **`references/examples/llvm-official/`** — 5 official LLVM 18 checker implementations
+   with explanatory comments:
+   - `01_div_zero.cpp` — simplest checker (169 lines, 1 callback)
+   - `02_simple_stream.cpp` — resource tracking (292 lines, fopen/fclose)
+   - `03_undef_result.cpp` — PostStmt pattern (160 lines)
+   - `04_nullability.cpp` — multi-callback checker (1247 lines)
+   - `05_malloc.cpp` — comprehensive malloc/free (1511 lines)
+
+4. **`checker_template.cpp`** — Skeleton with placeholders. Start here.
+
+5. **`references/repo_knowledge.md`** — Project-specific reference. Contains this
+   repository's memory allocation API, key data types, source layout, and typical
+   CVE patterns. **Read this before writing the checker** — knowing the project's
+   alloc/free conventions and common bug patterns saves many grep rounds.
+
+5b. **`references/patterns_summary.md`** — (may not exist) Historical synthesis
+   patterns for this project.  If present, it contains a concise summary of the
+   most common bug patterns, frequent CWE categories, and reusable checker
+   architectures observed in previous synthesis runs.  Read after repo_knowledge.md.
+
+6. **`references/cwe_cards/`** — Complete CWE knowledge base covering all
+   vulnerability categories.  **The framework provides the full library —
+   you must identify the vulnerability type yourself.**  Workflow:
+
+   1. Analyse the patch diff and commit message to determine the vulnerability
+      type (buffer overflow, UAF, null deref, integer overflow, race condition,
+      etc.).  Do NOT rely on the CWE label — treat it as a hint at most.
+   2. Open ``index.json`` to discover available cards and their tiers.
+   3. Read the relevant card(s) for **detection strategies**, **checker
+      architecture suggestions**, and **known false-positive patterns**.
+
+   Card tiers:
+   - ``CWE-{id}(-{variant}).md`` — Tier 1/2 cards for common CWEs; kernel /
+     userspace variants when the detection strategy differs substantially.
+   - ``Category-{name}.md`` — Tier 3 umbrella cards grouping rarer CWEs by
+     category (input validation, resource management, etc.).
+
+7. **`references/csa_utility_functions.h`** — Copy-paste C++ helper functions for
+   checker.cpp. Includes AST traversal (`findSpecificTypeInParents/Children`),
+   expression evaluation (`EvaluateExprToInt`, `inferSymbolMaxVal`), array/string
+   size extraction, MemRegion helpers, and `ExprHasName()` for robust function
+   matching. All verified against LLVM 18. **Read before implementing detection
+   logic** — these save writing boilerplate that's easy to get wrong.
+
+## Environment
+
+Key paths are in ``config.json``.
+
+### Pre-built scripts
+
+| Script | What it does |
+|--------|-------------|
+| `bash compile.sh` | Compile checker.cpp → checker.so (with correct flags) |
+| `CHECKER_NAME=<name> bash scan/scan_before.sh` | Scan before_commit, count warnings → N_buggy |
+| `CHECKER_NAME=<name> bash scan/scan_after.sh` | Scan after_commit, count warnings → N_patched |
+
+```bash
+# Compile (run from workdir root)
+bash compile.sh
+
+# Scan — set CHECKER_NAME to the string passed to addChecker<>()
+CHECKER_NAME=your.CheckerName bash scan/scan_before.sh   # → N_buggy
+CHECKER_NAME=your.CheckerName bash scan/scan_after.sh    # → N_patched
+```
+
+- ``compile.sh`` already has the correct ``-I`` / ``-fno-rtti`` flags.
+- ``scan/scan_*.sh`` count only warnings tagged with your checker name.
+- Scan environments (source files + compile flags) are pre-built in ``scan/``.
+
+### Scan Script Integrity (CRITICAL)
+
+The scan scripts (``scan/scan_before.sh``, ``scan/scan_after.sh``) are the **only
+valid measurement** of N_buggy and N_patched.  They are the ground truth that the
+Python-side validator will also use.  You MUST obey these rules:
+
+**1. Never bypass the scan scripts.**  Do NOT run ``clang --analyze`` directly
+   to measure warning counts.  The Python validator runs the same scan scripts
+   — if you measured with a different command, your numbers will not reproduce
+   and the synthesis will be rejected.
+
+**2. If the scan script prints COMPILE_ERROR** (missing headers, undeclared
+   identifiers, etc.), the scan environment needs repair.  You MUST fix it:
+   - Add missing ``-I`` include paths to the flags files in ``scan/``
+   - Copy needed generated headers (e.g. ``autoconf.h``) from the snapshot
+   - If the file fundamentally cannot be compiled by clang, stop and write
+     ``summary.json`` with ``status: "failed"`` and an honest ``failure_reason``
+
+**3. Only trust scan script output.**  The ``Total <name> warnings: N`` line
+   printed by the scan script is the number that goes into ``summary.json``.
+   If the scan script says 0, write 0.  Fabricating numbers that the scan
+   script did not produce will cause the Python validator to reject the
+   synthesis.
+
+- If compile fails: read the error, fix ``checker.cpp``, retry (max 3 cycles).
+- If validation fails: revise checker logic, re-compile, re-scan.
+
+## MCP Tools
+
+You have access to 3 MCP tools under the `csa-tools` server (prefixed `mcp__csa-tools__`).
+Each returns **source context embedded in the result** — no need to follow up with Read.
+
+| Tool | What it does | Key advantage |
+|------|-------------|---------------|
+| `search(pattern, scope)` | Search for a pattern in source / LLVM headers / workdir | Returns file:line + 3 lines context — grep + Read in one call |
+| `compile()` | Run compile.sh, return parsed diagnostics | Errors include checker.cpp context — fix without reading the file |
+| `scan(checker_name)` | Run before/after scan, return N_buggy + N_patched + warning locations | Each warning includes source context — no manual clang --analyze needed |
+
+### When to use each
+
+- **`search`**: Whenever you would type `grep -rn "X"` or `find ... -name`. Use `scope="source"` for CVE code, `scope="llvm"` for CSA API headers, `scope="all"` when unsure.
+- **`compile`**: Instead of `bash compile.sh` followed by reading checker.cpp at error lines.
+- **`scan`**: Instead of running scan_before.sh + scan_after.sh + manual clang inspection. Returns everything you need to decide next action.
+
+## Semantic Design Contract — before writing checker.cpp
+
+Create the analysis portions of `state.json` and `scope_statement.md` **before**
+writing checker.cpp. They are a design contract, not a retrospective summary.
+After compilation, update only implementation facts such as `build_attempts`.
+
+In `patch_analysis`, distinguish the vulnerable operation, its trigger, and the
+semantic fact introduced by the patch that makes it safe. In `detection_plan`,
+make `report_condition`, `safe_condition`, and `source_level_signal` concrete
+CSA-observable facts. In `api_choice`, record the mechanism level and explain
+why the selected callback can observe and prove those facts.
+
+In `scope_statement.md`, include this mapping table and check it again after
+implementation:
+
+| Semantic condition | CSA evidence | checker.cpp implementation |
+| --- | --- | --- |
+| report condition | AST / SVal / MemRegion / CFG evidence | callback, helper, and branch that reports |
+| safe condition | path constraint, guard, state discharge, or structural fact | branch that suppresses the report |
+
+Every condition in the plan must have an implementation entry. Do not claim a
+condition that checker.cpp does not implement, and do not silently add a code
+condition absent from the plan.
+
+## Mechanism Selection — diagnose before coding
+
+Choose the weakest CSA mechanism that can prove the vulnerability property:
+
+1. **syntax-only AST**: only when local AST shape itself is the defect;
+2. **control flow / dominance**: when guard placement relative to a sink matters;
+3. **path-sensitive ProgramState/SVal**: when an unsafe state must reach a use;
+4. **cross-procedure/dataflow**: when the required fact crosses function boundaries.
+
+For a guard-based patch, prove both that the guard rejects the unsafe value and
+that it dominates the vulnerable use. For path-sensitive or cross-procedure
+defects, do not replace the required state or flow proof with local AST matching
+or source-text substring matching merely because it passes the differential scan.
+Record the selected level as `api_choice.mechanism_level`.
+
+## Semantic identity, locality, and final validation
+
+Before accepting the checker, verify that its primary matching logic does not
+depend on patch-local variable names, labels, line numbers, commit IDs, or unique
+literals. Project APIs, types, and stable semantic call relationships are valid
+scope anchors when they define the vulnerability class. Attach the report to the
+actual vulnerable operation, and implement every suppression as a real safe
+condition rather than the mere presence of a nearby guard-shaped statement.
+
+The required final sequence is: **compile → before scan → after scan → inspect
+the final checker name, artifacts, and report locations → write summary.json**.
+Always run the final compile and both scans. `MAX_IN_SESSION_REDESIGNS` limits only
+additional redesign cycles after a failed validation; if it is zero, preserve the
+real validation evidence and report failure honestly rather than fabricating counts.
+
+## Validation Criteria
+
+```
+VALID   : N_buggy > N_patched  AND  N_patched < 50
+INVALID : otherwise → revise and re-validate (max 1 attempts)
+```
+
+## Refinement
+
+Do NOT self-refine the checker repeatedly. Your goal is to produce the first
+checker that passes the Validation Criteria above — fix compile errors and
+validation failures only. False positives are triaged and repaired by the
+framework's refinement stage: you will receive a concrete FP list via
+session resume (if needed) and fix only those. Reserve budget for that stage.
+
+## Output
+
+Produce all of the following **only when completely done**:
+
+| File | Content |
+|------|---------|
+| ``checker.cpp`` | Synthesized checker source code |
+| ``checker.so`` | Compiled checker plugin |
+| ``state.json`` | Structured task state (see schema below) |
+| ``scope_statement.md`` | Checker scope analysis in prose (Level 1/2/3) |
+| ``summary.json`` | Final report (see schema below) |
+
+Writing ``summary.json`` signals completion.  Do NOT write it early.
+
+### ``state.json``
+
+Create this before writing checker.cpp to capture the design contract. After the
+checker compiles, update only implementation facts and retain the original
+semantic plan.
+
+```json
+{
+  "patch_analysis": {
+    "summary":           "One sentence describing the vulnerability this patch fixes",
+    "changed_files":     ["file1.c", "file2.h"],
+    "changed_functions": ["func_a", "func_b"],
+    "bug_type":          "buffer_overflow | use_after_free | null_deref | integer_overflow | race_condition | resource_leak | double_free | input_validation | other",
+    "fix_strategy":      "add_bounds_check | add_null_check | add_size_check | add_early_return | reorder_operations | change_api_signature | other",
+    "affected_types":    ["GF_BitStream", "custom_struct_t"],
+    "critical_calls":    ["gf_strdup", "memcpy"]
+  },
+  "detection_plan": {
+    "bug_pattern":         "High-level description of the vulnerability pattern (e.g. 'heap buffer overflow when reading variable-length data into a fixed-size stack buffer without size bound')",
+    "report_condition":    "When should the checker emit a warning? (e.g. 'call to gf_strdup where the argument originates from a fixed-size local array that was populated by variable-length bitstream reads')",
+    "safe_condition":      "When should the checker NOT emit a warning? (e.g. 'argument originates from a heap allocation or a size-bounded source')",
+    "source_level_signal": "What AST / MemRegion / SVal property does the checker look for? (e.g. 'MemRegion extent < parameter size at a PreCall to gf_strdup')"
+  },
+  "api_choice": {
+    "mechanism_level":          "syntactic_ast | control_flow | path_sensitive | interprocedural_dataflow",
+    "callback":                 "check::PreCall | check::PostCall | check::PreStmt | check::PostStmt | check::Bind | check::DeadSymbols | check::EndFunction | ...",
+    "reasoning":                "Why this callback and its AST/state/CFG evidence prove the report and safe conditions",
+    "alternatives_considered":  ["check::PostCall"]
+  },
+  "implementation": {
+    "scope_level":    "patch_specific | project_general | cross_project",
+    "checker_name":   "project.CheckerName",
+    "build_attempts": 1
+  }
+}
+```
+
+### ``summary.json``
+
+```json
+{
+  "status":           "plausible | failed",
+  "bug_pattern":      "One sentence describing the bug pattern",
+  "scope_level":      "patch_specific | project_general | cross_project",
+  "checker_cpp":      "checker.cpp",
+  "checker_so":       "checker.so",
+  "n_buggy":          0,
+  "n_patched":        0,
+  "total_reports":    0,
+  "fp_rate_estimate": 0.0,
+  "failure_reason":   null
+}
+```
+
+## Feedback-derived requirements for this fresh synthesis
+
+A prior independent rollout exposed the risks below. Start again from the patch
+in this new session. Do not reconstruct, edit, or assume the prior checker.
+
+Required mechanism level: `path_sensitive`
+
+### Current failure diagnosis
+
+- The prior checker tracked an acquired object until an explicit common cleanup, but never cleared or transferred that obligation after backend setup succeeded; it therefore reported the later engine_init_common failure even though backend teardown owns the object at that point.
+- Suffix-based acquire and release matching generalized beyond the specific engine initialization protocol, leaving semantic ownership insufficiently modeled.
+- The rollout remained refinement-unaccepted because its semantic result was only partial, and process quality was below threshold despite successful compilation, validation, and hardcoding checks.
+
+### Preserve from prior rollouts
+
+- Preserve successful compilation, before/after validation, and code verification.
+- Preserve objective eligibility gate G6.
+- Preserve the previously adequate path-sensitive CSA mechanism level.
+- Preserve semantic score at or above the configured threshold.
+- Do not introduce dependence on patch anchors such as changed line numbers, local patch text, or exact diff locations.
+- Do not introduce patch-local hardcoding.
+
+### Required semantic proof
+
+- On a path where engine_setup_common(engine) successfully acquires common resources, establish that a nonzero return from the subsequent backend setup(engine) is an error path requiring intel_engine_cleanup_common(engine).
+- Suppress the diagnostic when the acquisition call itself returns the failing value, because that path does not establish a successfully acquired resource.
+- Discharge the common-resource obligation when intel_engine_cleanup_common(engine) executes on the same path.
+- Model successful backend setup(engine) as an ownership transfer to the backend, so a later engine_init_common(engine) failure is not reported as a missing common cleanup.
+- Report the vulnerable return locally in intel_engines_init at the failed backend setup path, and distinguish it from normal zero returns and ownership-transferred paths.
+
+### Implementation constraints
+
+- Use ProgramState to carry the per-object acquisition, release, acquisition-result, and ownership-transfer facts along each path.
+- Use check::PostCall to observe the relevant helper calls and setup result, and check::PreStmt<ReturnStmt> to inspect the same-path obligation and prove a nonzero integer error return.
+- Key tracked facts by the managed object region and preserve frame ownership so diagnostics are not emitted for unrelated inlined callees or objects.
+- Recognize the specific project protocol represented by engine_setup_common, intel_engine_cleanup_common, setup, and engine_init_common rather than relying on unrestricted suffix-only helper matching.
+- Attach the report to the actual error return and the tracked object, with no diagnostics for normal returns, unconstrained return values, or non-error return types.
+- Keep the checker project-general over the documented helper and ownership convention; do not encode patch line numbers, changed text, local variable names, or exact patch anchors.
+
+### Validation checklist
+
+- Compile the new checker successfully against the CSA API and verify that the produced checker artifact loads.
+- Run both vulnerable and patched revisions through the scan and code-verification validation without regressing hard validation.
+- Confirm the vulnerable revision reports the failed setup(engine) return in intel_engines_init and that the patched revision has no corresponding report there.
+- Confirm the later engine_init_common failure is not reported in the patched revision because successful setup transferred teardown responsibility.
+- Verify that acquisition-self-failure paths, zero returns, and paths with explicit intel_engine_cleanup_common do not produce diagnostics.
+- Verify differential and scope behavior: the relevant warning disappears after the patch, no unrelated non-patched warnings disappear, and report locations remain near the affected function.
+- Recheck anchor-free and hardcoding-free status, objective gate G6, semantic mechanism level, and configured semantic-score threshold.
+
+### Avoid and forbidden regressions
+
+- Do not treat every still-pending explicit cleanup obligation as a leak after successful backend setup; represent ownership transfer before evaluating later returns.
+- Do not use syntax-only matching of an if-and-return shape, EndFunction, or PostStmt<ReturnStmt> as the primary proof of the path-specific defect.
+- Do not report merely because a resource lacks an explicit common cleanup when backend ownership has been established.
+- Do not broaden matching to arbitrary names that happen to share acquire or release suffixes without proving the corresponding object protocol.
+- Do not weaken the accepted path-sensitive contract to improve process or differential scores.
+- Do not regress compilation, before/after validation, code verification, objective eligibility, semantic adequacy, anchor independence, or hardcoding independence.

tasks/csa159/pair_164760/checker_template.cpp

@@ -0,0 +1,98 @@
+// ============================================================================
+// CSA Checker Template
+// ============================================================================
+// Fill in the sections marked with TODO to implement your checker.
+// The checker is compiled with -fno-rtti to match the LLVM 18 build config.
+// It is loaded via: clang -cc1 -load checker.so -analyzer-checker=your.CheckerName
+//
+// Compilation:
+//   clang++ -std=c++17 -fPIC -shared -fno-rtti -fno-exceptions \
+//           -I${LLVM_BUILD_DIR}/include \
+//           checker.cpp -o checker.so \
+//           -Wl,--allow-shlib-undefined
+//
+// Usage:
+//   clang -cc1 -load ./checker.so -analyzer-checker=your.CheckerName -analyze <file>
+// ============================================================================
+
+#include "clang/StaticAnalyzer/Core/BugReporter/BugReporter.h"
+#include "clang/StaticAnalyzer/Core/BugReporter/BugType.h"
+#include "clang/StaticAnalyzer/Core/Checker.h"
+#include "clang/StaticAnalyzer/Core/PathSensitive/CallEvent.h"
+#include "clang/StaticAnalyzer/Core/PathSensitive/CheckerContext.h"
+#include "clang/StaticAnalyzer/Frontend/CheckerRegistry.h"
+
+using namespace clang;
+using namespace ento;
+
+namespace {
+
+// ────────────────────────────────────────────────────────────────
+// TODO: Rename this class to describe your checker's purpose.
+// ────────────────────────────────────────────────────────────────
+class {{CHECKER_CLASS_NAME}}
+    : public Checker<check::PreCall,      // for checking before function calls
+                     check::PostCall>     // for checking after function calls
+{
+  // TODO: Customize the bug type name and category.
+  mutable std::unique_ptr<BugType> BT;
+
+public:
+  {{CHECKER_CLASS_NAME}}()
+      : BT(new BugType(this, "{{BUG_NAME}}", "{{BUG_CATEGORY}}")) {}
+
+  // ── PreCall callback (fires before every function call) ──────
+  void checkPreCall(const CallEvent &Call, CheckerContext &C) const {
+    // TODO: Implement your pre-call analysis logic here.
+    //
+    // Common patterns:
+    //
+    // 1. Check if the called function matches a specific name:
+    //    if (Call.getCalleeIdentifier()) {
+    //      StringRef name = Call.getCalleeIdentifier()->getName();
+    //      if (name == "target_function") { ... }
+    //    }
+    //
+    // 2. Get the program state:
+    //    ProgramStateRef State = C.getState();
+    //
+    // 3. Get arguments:
+    //    SVal Arg = Call.getArgSVal(0);
+    //
+    // 4. Generate a bug report:
+    //    ExplodedNode *ErrNode = C.generateErrorNode();
+    //    if (ErrNode) {
+    //      auto R = std::make_unique<PathSensitiveBugReport>(
+    //          *BT, "Description of the bug", ErrNode);
+    //      C.emitReport(std::move(R));
+    //    }
+  }
+
+  // ── PostCall callback (fires after every function call) ─────
+  void checkPostCall(const CallEvent &Call, CheckerContext &C) const {
+    // TODO: Implement your post-call analysis logic here.
+    //
+    // Common pattern — check the return value:
+    //   SVal RetVal = Call.getReturnValue();
+    //   if (RetVal.isUnknownOrUndef()) return;
+    //
+    //   ProgramStateRef State = C.getState();
+    //   // Modify state based on post-call conditions...
+  }
+};
+
+} // anonymous namespace
+
+// ────────────────────────────────────────────────────────────────
+// Registration — DO NOT modify the function signatures.
+// ────────────────────────────────────────────────────────────────
+
+extern "C" void clang_registerCheckers(CheckerRegistry &registry) {
+  registry.addChecker<{{CHECKER_CLASS_NAME}}>(
+      "{{CHECKER_FULL_NAME}}",  // e.g., "your.NullDereferenceChecker"
+      "{{CHECKER_DESC}}",       // e.g., "Detects null pointer dereference"
+      "{{CHECKER_DOC_URI}}");   // e.g., "https://example.com/docs"
+}
+
+extern "C" const char clang_analyzerAPIVersionString[] =
+    CLANG_ANALYZER_API_VERSION_STRING;

tasks/csa159/pair_164760/config.json

@@ -0,0 +1,19 @@
+{
+  "project_id": "torvalds_linux",
+  "before_commit": "965adae5a33a998e2b62ec1b37c5eb21f1875b15",
+  "after_commit": "15a901361ec3fb1c393f91880e1cbf24ec0a88bd",
+  "repo_path": "/workspace/repo/torvalds/linux",
+  "llvm_build_dir": "/opt/llvm",
+  "before_compile_commands": "/workspace/benchmark/data-pipeline/snapshots/torvalds_linux/ffd294d346d185b70e28b1a28abe367bbfe53c04/compile_commands.json",
+  "after_compile_commands": "/workspace/benchmark/data-pipeline/snapshots/torvalds_linux/ffd294d346d185b70e28b1a28abe367bbfe53c04/compile_commands.json",
+  "changed_files": [
+    "net/ipv4/ipmr_base.c"
+  ],
+  "commit_message": "ipmr: do not call mr_mfc_uses_dev() for unres entries\n\nsyzbot found that calling mr_mfc_uses_dev() for unres entries\nwould crash [1], because c->mfc_un.res.minvif / c->mfc_un.res.maxvif\nalias to \"struct sk_buff_head unresolved\", which contain two pointers.\n\nThis code never worked, lets remove it.\n\n[1]\nUnable to handle kernel paging request at virtual address ffff5fff2d536613\nKASAN: maybe wild-memory-access in range [0xfffefff96a9b3098-0xfffefff96a9b309f]\nModules linked in:\nCPU: 1 UID: 0 PID: 7321 Comm: syz.0.16 Not tainted 6.13.0-rc7-syzkaller-g1950a0af2d55 #0\nHardware name: Google Google Compute Engine/Google Compute Engine, BIOS Google 09/13/2024\npstate: 80400005 (Nzcv daif +PAN -UAO -TCO -DIT -SSBS BTYPE=--)\n pc : mr_mfc_uses_dev net/ipv4/ipmr_base.c:290 [inline]\n pc : mr_table_dump+0x5a4/0x8b0 net/ipv4/ipmr_base.c:334\n lr : mr_mfc_uses_dev net/ipv4/ipmr_base.c:289 [inline]\n lr : mr_table_dump+0x694/0x8b0 net/ipv4/ipmr_base.c:334\nCall trace:\n  mr_mfc_uses_dev net/ipv4/ipmr_base.c:290 [inline] (P)\n  mr_table_dump+0x5a4/0x8b0 net/ipv4/ipmr_base.c:334 (P)\n  mr_rtm_dumproute+0x254/0x454 net/ipv4/ipmr_base.c:382\n  ipmr_rtm_dumproute+0x248/0x4b4 net/ipv4/ipmr.c:2648\n  rtnl_dump_all+0x2e4/0x4e8 net/core/rtnetlink.c:4327\n  rtnl_dumpit+0x98/0x1d0 net/core/rtnetlink.c:6791\n  netlink_dump+0x4f0/0xbc0 net/netlink/af_netlink.c:2317\n  netlink_recvmsg+0x56c/0xe64 net/netlink/af_netlink.c:1973\n  sock_recvmsg_nosec net/socket.c:1033 [inline]\n  sock_recvmsg net/socket.c:1055 [inline]\n  sock_read_iter+0x2d8/0x40c net/socket.c:1125\n  new_sync_read fs/read_write.c:484 [inline]\n  vfs_read+0x740/0x970 fs/read_write.c:565\n  ksys_read+0x15c/0x26c fs/read_write.c:708\n\nFixes: cb167893f41e (\"net: Plumb support for filtering ipv4 and ipv6 multicast route dumps\")\nReported-by: syzbot+5cfae50c0e5f2c500013@syzkaller.appspotmail.com\nCloses: https://lore.kernel.org/netdev/678fe2d1.050a0220.15cac.00b3.GAE@google.com/T/#u\nSigned-off-by: Eric Dumazet <edumazet@google.com>\nReviewed-by: David Ahern <dsahern@kernel.org>\nLink: https://patch.msgid.link/20250121181241.841212-1-edumazet@google.com\nSigned-off-by: Jakub Kicinski <kuba@kernel.org>",
+  "t_valid": 50,
+  "t_plausible": 20,
+  "triage_sample_size": 10,
+  "max_synthesis_retry": 0,
+  "max_in_session_redesigns": 1,
+  "max_refinement_iter": 3
+}

tasks/csa159/pair_164760/patch.diff

@@ -0,0 +1,14 @@
+diff --git a/net/ipv4/ipmr_base.c b/net/ipv4/ipmr_base.c
+index 03b6eee407a2..28d77d454d44 100644
+--- a/net/ipv4/ipmr_base.c
++++ b/net/ipv4/ipmr_base.c
+@@ -330,9 +330,6 @@ int mr_table_dump(struct mr_table *mrt, struct sk_buff *skb,
+ 	list_for_each_entry(mfc, &mrt->mfc_unres_queue, list) {
+ 		if (e < s_e)
+ 			goto next_entry2;
+-		if (filter->dev &&
+-		    !mr_mfc_uses_dev(mrt, mfc, filter->dev))
+-			goto next_entry2;
+ 
+ 		err = fill(mrt, skb, NETLINK_CB(cb->skb).portid,
+ 			   cb->nlh->nlmsg_seq, mfc, RTM_NEWROUTE, flags);

tasks/csa159/pair_164760/post_functions.txt

@@ -0,0 +1,54 @@
+### File: net/ipv4/ipmr_base.c
+```c
+int mr_table_dump(struct mr_table *mrt, struct sk_buff *skb,
+		  struct netlink_callback *cb,
+		  int (*fill)(struct mr_table *mrt, struct sk_buff *skb,
+			      u32 portid, u32 seq, struct mr_mfc *c,
+			      int cmd, int flags),
+		  spinlock_t *lock, struct fib_dump_filter *filter)
+{
+	unsigned int e = 0, s_e = cb->args[1];
+	unsigned int flags = NLM_F_MULTI;
+	struct mr_mfc *mfc;
+	int err;
+
+	if (filter->filter_set)
+		flags |= NLM_F_DUMP_FILTERED;
+
+	list_for_each_entry_rcu(mfc, &mrt->mfc_cache_list, list,
+				lockdep_rtnl_is_held()) {
+		if (e < s_e)
+			goto next_entry;
+		if (filter->dev &&
+		    !mr_mfc_uses_dev(mrt, mfc, filter->dev))
+			goto next_entry;
+
+		err = fill(mrt, skb, NETLINK_CB(cb->skb).portid,
+			   cb->nlh->nlmsg_seq, mfc, RTM_NEWROUTE, flags);
+		if (err < 0)
+			goto out;
+next_entry:
+		e++;
+	}
+
+	spin_lock_bh(lock);
+	list_for_each_entry(mfc, &mrt->mfc_unres_queue, list) {
+		if (e < s_e)
+			goto next_entry2;
+
+		err = fill(mrt, skb, NETLINK_CB(cb->skb).portid,
+			   cb->nlh->nlmsg_seq, mfc, RTM_NEWROUTE, flags);
+		if (err < 0) {
+			spin_unlock_bh(lock);
+			goto out;
+		}
+next_entry2:
+		e++;
+	}
+	spin_unlock_bh(lock);
+	err = 0;
+out:
+	cb->args[1] = e;
+	return err;
+}
+```

tasks/csa159/pair_164760/pre_functions.txt

@@ -0,0 +1,57 @@
+### File: net/ipv4/ipmr_base.c
+```c
+int mr_table_dump(struct mr_table *mrt, struct sk_buff *skb,
+		  struct netlink_callback *cb,
+		  int (*fill)(struct mr_table *mrt, struct sk_buff *skb,
+			      u32 portid, u32 seq, struct mr_mfc *c,
+			      int cmd, int flags),
+		  spinlock_t *lock, struct fib_dump_filter *filter)
+{
+	unsigned int e = 0, s_e = cb->args[1];
+	unsigned int flags = NLM_F_MULTI;
+	struct mr_mfc *mfc;
+	int err;
+
+	if (filter->filter_set)
+		flags |= NLM_F_DUMP_FILTERED;
+
+	list_for_each_entry_rcu(mfc, &mrt->mfc_cache_list, list,
+				lockdep_rtnl_is_held()) {
+		if (e < s_e)
+			goto next_entry;
+		if (filter->dev &&
+		    !mr_mfc_uses_dev(mrt, mfc, filter->dev))
+			goto next_entry;
+
+		err = fill(mrt, skb, NETLINK_CB(cb->skb).portid,
+			   cb->nlh->nlmsg_seq, mfc, RTM_NEWROUTE, flags);
+		if (err < 0)
+			goto out;
+next_entry:
+		e++;
+	}
+
+	spin_lock_bh(lock);
+	list_for_each_entry(mfc, &mrt->mfc_unres_queue, list) {
+		if (e < s_e)
+			goto next_entry2;
+		if (filter->dev &&
+		    !mr_mfc_uses_dev(mrt, mfc, filter->dev))
+			goto next_entry2;
+
+		err = fill(mrt, skb, NETLINK_CB(cb->skb).portid,
+			   cb->nlh->nlmsg_seq, mfc, RTM_NEWROUTE, flags);
+		if (err < 0) {
+			spin_unlock_bh(lock);
+			goto out;
+		}
+next_entry2:
+		e++;
+	}
+	spin_unlock_bh(lock);
+	err = 0;
+out:
+	cb->args[1] = e;
+	return err;
+}
+```

tasks/csa159/pair_164760/task_prompt.md

@@ -0,0 +1,318 @@
+# Task: Synthesize a CSA Checker from a CVE Patch
+
+## Your Role
+
+You are a static analysis expert. Synthesize a Clang Static Analyzer (CSA) checker
+that detects the bug pattern fixed by the CVE patch in this working directory.
+
+You have full filesystem and bash access — use them.
+
+### Skills
+
+Many skills are available under `.claude/skills/` — covering vulnerability analysis,
+checker design, debugging, code audit, security patterns, and more.  Each skill
+encodes reusable expertise: take time to explore them, read their SKILL.md files,
+and invoke those that look useful via the Skill tool.  Let the task guide which
+ones you reach for.
+
+## File Layout
+
+```
+/work/
+├── compile.sh               ← RUN ME: compile checker.cpp → checker.so
+├── checker_template.cpp     ← skeleton, start here
+├── patch.diff               ← the CVE fix
+├── pre_functions.txt        ← buggy source (before_commit)
+├── post_functions.txt       ← patched source (after_commit)
+├── config.json              ← paths, commit_message, commit hashes, flags
+├── scan/
+│   ├── scan_before.sh       ← RUN ME: scan before_commit → N_buggy
+│   ├── scan_after.sh        ← RUN ME: scan after_commit → N_patched
+│   └── flags_*.txt          ← pre-extracted compile flags (-I, -D)
+├── references/
+│   ├── repo_knowledge.md            ← project-specific API/convention reference
+│   ├── patterns_summary.md       ← (optional) historical bug pattern summary
+│   ├── cwe_cards/                ← CWE knowledge library (all categories)
+│   │   ├── index.json             ← lookup index — use to find relevant cards
+│   │   ├── CWE-{id}(-variant).md  ← Tier 1/2 per-CWE detection patterns
+│   │   ├── Category-{name}.md     ← Tier 3 umbrella cards (rare CWEs grouped)
+│   ├── csa_headers_api.md   ← API quick reference (extracted from LLVM 18 headers)
+│   ├── csa_checker_patterns.md ← pattern catalog (resource tracking, null check, etc.)
+│   ├── csa_utility_functions.h ← copy-paste C++ helpers for checker.cpp (AST traversal, expression eval, etc.)
+│   └── examples/
+│       └── llvm-official/   ← 5 official checker sources (with comments)
+│           ├── 01_div_zero.cpp
+│           ├── 02_simple_stream.cpp
+│           ├── 03_undef_result.cpp
+│           ├── 04_nullability.cpp
+│           └── 05_malloc.cpp
+│
+├── checker.cpp              ← YOUR OUTPUT: synthesized checker
+├── checker.so               ← YOUR OUTPUT: compiled checker
+├── state.json               ← YOUR OUTPUT: structured task state
+├── scope_statement.md       ← YOUR OUTPUT: checker scope analysis (Level 1/2/3)
+└── summary.json             ← YOUR OUTPUT: final report
+```
+
+## Resources
+
+**Read these before writing any code:**
+
+1. **`references/csa_headers_api.md`** — CSA API quick reference. Extracted directly from
+   LLVM 18 headers. Covers all checker callbacks, ProgramState operations, SVal types,
+   MemRegion hierarchy, and bug reporting. **Read this first whenever you need API info.**
+
+2. **`references/csa_checker_patterns.md`** — Pattern catalog. Documents 5 battle-tested
+   patterns from official LLVM checkers: resource tracking, null checking, undefined
+   value detection, division-by-zero, and malloc/free. Each pattern includes skeleton
+   code, state traits, and key API usage.
+
+3. **`references/examples/llvm-official/`** — 5 official LLVM 18 checker implementations
+   with explanatory comments:
+   - `01_div_zero.cpp` — simplest checker (169 lines, 1 callback)
+   - `02_simple_stream.cpp` — resource tracking (292 lines, fopen/fclose)
+   - `03_undef_result.cpp` — PostStmt pattern (160 lines)
+   - `04_nullability.cpp` — multi-callback checker (1247 lines)
+   - `05_malloc.cpp` — comprehensive malloc/free (1511 lines)
+
+4. **`checker_template.cpp`** — Skeleton with placeholders. Start here.
+
+5. **`references/repo_knowledge.md`** — Project-specific reference. Contains this
+   repository's memory allocation API, key data types, source layout, and typical
+   CVE patterns. **Read this before writing the checker** — knowing the project's
+   alloc/free conventions and common bug patterns saves many grep rounds.
+
+5b. **`references/patterns_summary.md`** — (may not exist) Historical synthesis
+   patterns for this project.  If present, it contains a concise summary of the
+   most common bug patterns, frequent CWE categories, and reusable checker
+   architectures observed in previous synthesis runs.  Read after repo_knowledge.md.
+
+6. **`references/cwe_cards/`** — Complete CWE knowledge base covering all
+   vulnerability categories.  **The framework provides the full library —
+   you must identify the vulnerability type yourself.**  Workflow:
+
+   1. Analyse the patch diff and commit message to determine the vulnerability
+      type (buffer overflow, UAF, null deref, integer overflow, race condition,
+      etc.).  Do NOT rely on the CWE label — treat it as a hint at most.
+   2. Open ``index.json`` to discover available cards and their tiers.
+   3. Read the relevant card(s) for **detection strategies**, **checker
+      architecture suggestions**, and **known false-positive patterns**.
+
+   Card tiers:
+   - ``CWE-{id}(-{variant}).md`` — Tier 1/2 cards for common CWEs; kernel /
+     userspace variants when the detection strategy differs substantially.
+   - ``Category-{name}.md`` — Tier 3 umbrella cards grouping rarer CWEs by
+     category (input validation, resource management, etc.).
+
+7. **`references/csa_utility_functions.h`** — Copy-paste C++ helper functions for
+   checker.cpp. Includes AST traversal (`findSpecificTypeInParents/Children`),
+   expression evaluation (`EvaluateExprToInt`, `inferSymbolMaxVal`), array/string
+   size extraction, MemRegion helpers, and `ExprHasName()` for robust function
+   matching. All verified against LLVM 18. **Read before implementing detection
+   logic** — these save writing boilerplate that's easy to get wrong.
+
+## Environment
+
+Key paths are in ``config.json``.
+
+### Pre-built scripts
+
+| Script | What it does |
+|--------|-------------|
+| `bash compile.sh` | Compile checker.cpp → checker.so (with correct flags) |
+| `CHECKER_NAME=<name> bash scan/scan_before.sh` | Scan before_commit, count warnings → N_buggy |
+| `CHECKER_NAME=<name> bash scan/scan_after.sh` | Scan after_commit, count warnings → N_patched |
+
+```bash
+# Compile (run from workdir root)
+bash compile.sh
+
+# Scan — set CHECKER_NAME to the string passed to addChecker<>()
+CHECKER_NAME=your.CheckerName bash scan/scan_before.sh   # → N_buggy
+CHECKER_NAME=your.CheckerName bash scan/scan_after.sh    # → N_patched
+```
+
+- ``compile.sh`` already has the correct ``-I`` / ``-fno-rtti`` flags.
+- ``scan/scan_*.sh`` count only warnings tagged with your checker name.
+- Scan environments (source files + compile flags) are pre-built in ``scan/``.
+
+### Scan Script Integrity (CRITICAL)
+
+The scan scripts (``scan/scan_before.sh``, ``scan/scan_after.sh``) are the **only
+valid measurement** of N_buggy and N_patched.  They are the ground truth that the
+Python-side validator will also use.  You MUST obey these rules:
+
+**1. Never bypass the scan scripts.**  Do NOT run ``clang --analyze`` directly
+   to measure warning counts.  The Python validator runs the same scan scripts
+   — if you measured with a different command, your numbers will not reproduce
+   and the synthesis will be rejected.
+
+**2. If the scan script prints COMPILE_ERROR** (missing headers, undeclared
+   identifiers, etc.), the scan environment needs repair.  You MUST fix it:
+   - Add missing ``-I`` include paths to the flags files in ``scan/``
+   - Copy needed generated headers (e.g. ``autoconf.h``) from the snapshot
+   - If the file fundamentally cannot be compiled by clang, stop and write
+     ``summary.json`` with ``status: "failed"`` and an honest ``failure_reason``
+
+**3. Only trust scan script output.**  The ``Total <name> warnings: N`` line
+   printed by the scan script is the number that goes into ``summary.json``.
+   If the scan script says 0, write 0.  Fabricating numbers that the scan
+   script did not produce will cause the Python validator to reject the
+   synthesis.
+
+- If compile fails: read the error, fix ``checker.cpp``, retry (max 3 cycles).
+- If validation fails: revise checker logic, re-compile, re-scan.
+
+## MCP Tools
+
+You have access to 3 MCP tools under the `csa-tools` server (prefixed `mcp__csa-tools__`).
+Each returns **source context embedded in the result** — no need to follow up with Read.
+
+| Tool | What it does | Key advantage |
+|------|-------------|---------------|
+| `search(pattern, scope)` | Search for a pattern in source / LLVM headers / workdir | Returns file:line + 3 lines context — grep + Read in one call |
+| `compile()` | Run compile.sh, return parsed diagnostics | Errors include checker.cpp context — fix without reading the file |
+| `scan(checker_name)` | Run before/after scan, return N_buggy + N_patched + warning locations | Each warning includes source context — no manual clang --analyze needed |
+
+### When to use each
+
+- **`search`**: Whenever you would type `grep -rn "X"` or `find ... -name`. Use `scope="source"` for CVE code, `scope="llvm"` for CSA API headers, `scope="all"` when unsure.
+- **`compile`**: Instead of `bash compile.sh` followed by reading checker.cpp at error lines.
+- **`scan`**: Instead of running scan_before.sh + scan_after.sh + manual clang inspection. Returns everything you need to decide next action.
+
+## Semantic Design Contract — before writing checker.cpp
+
+Create the analysis portions of `state.json` and `scope_statement.md` **before**
+writing checker.cpp. They are a design contract, not a retrospective summary.
+After compilation, update only implementation facts such as `build_attempts`.
+
+In `patch_analysis`, distinguish the vulnerable operation, its trigger, and the
+semantic fact introduced by the patch that makes it safe. In `detection_plan`,
+make `report_condition`, `safe_condition`, and `source_level_signal` concrete
+CSA-observable facts. In `api_choice`, record the mechanism level and explain
+why the selected callback can observe and prove those facts.
+
+In `scope_statement.md`, include this mapping table and check it again after
+implementation:
+
+| Semantic condition | CSA evidence | checker.cpp implementation |
+| --- | --- | --- |
+| report condition | AST / SVal / MemRegion / CFG evidence | callback, helper, and branch that reports |
+| safe condition | path constraint, guard, state discharge, or structural fact | branch that suppresses the report |
+
+Every condition in the plan must have an implementation entry. Do not claim a
+condition that checker.cpp does not implement, and do not silently add a code
+condition absent from the plan.
+
+## Mechanism Selection — diagnose before coding
+
+Choose the weakest CSA mechanism that can prove the vulnerability property:
+
+1. **syntax-only AST**: only when local AST shape itself is the defect;
+2. **control flow / dominance**: when guard placement relative to a sink matters;
+3. **path-sensitive ProgramState/SVal**: when an unsafe state must reach a use;
+4. **cross-procedure/dataflow**: when the required fact crosses function boundaries.
+
+For a guard-based patch, prove both that the guard rejects the unsafe value and
+that it dominates the vulnerable use. For path-sensitive or cross-procedure
+defects, do not replace the required state or flow proof with local AST matching
+or source-text substring matching merely because it passes the differential scan.
+Record the selected level as `api_choice.mechanism_level`.
+
+## Semantic identity, locality, and final validation
+
+Before accepting the checker, verify that its primary matching logic does not
+depend on patch-local variable names, labels, line numbers, commit IDs, or unique
+literals. Project APIs, types, and stable semantic call relationships are valid
+scope anchors when they define the vulnerability class. Attach the report to the
+actual vulnerable operation, and implement every suppression as a real safe
+condition rather than the mere presence of a nearby guard-shaped statement.
+
+The required final sequence is: **compile → before scan → after scan → inspect
+the final checker name, artifacts, and report locations → write summary.json**.
+Always run the final compile and both scans. `MAX_IN_SESSION_REDESIGNS` limits only
+additional redesign cycles after a failed validation; if it is zero, preserve the
+real validation evidence and report failure honestly rather than fabricating counts.
+
+## Validation Criteria
+
+```
+VALID   : N_buggy > N_patched  AND  N_patched < 50
+INVALID : otherwise → revise and re-validate (max 1 attempts)
+```
+
+## Refinement
+
+Do NOT self-refine the checker repeatedly. Your goal is to produce the first
+checker that passes the Validation Criteria above — fix compile errors and
+validation failures only. False positives are triaged and repaired by the
+framework's refinement stage: you will receive a concrete FP list via
+session resume (if needed) and fix only those. Reserve budget for that stage.
+
+## Output
+
+Produce all of the following **only when completely done**:
+
+| File | Content |
+|------|---------|
+| ``checker.cpp`` | Synthesized checker source code |
+| ``checker.so`` | Compiled checker plugin |
+| ``state.json`` | Structured task state (see schema below) |
+| ``scope_statement.md`` | Checker scope analysis in prose (Level 1/2/3) |
+| ``summary.json`` | Final report (see schema below) |
+
+Writing ``summary.json`` signals completion.  Do NOT write it early.
+
+### ``state.json``
+
+Create this before writing checker.cpp to capture the design contract. After the
+checker compiles, update only implementation facts and retain the original
+semantic plan.
+
+```json
+{
+  "patch_analysis": {
+    "summary":           "One sentence describing the vulnerability this patch fixes",
+    "changed_files":     ["file1.c", "file2.h"],
+    "changed_functions": ["func_a", "func_b"],
+    "bug_type":          "buffer_overflow | use_after_free | null_deref | integer_overflow | race_condition | resource_leak | double_free | input_validation | other",
+    "fix_strategy":      "add_bounds_check | add_null_check | add_size_check | add_early_return | reorder_operations | change_api_signature | other",
+    "affected_types":    ["GF_BitStream", "custom_struct_t"],
+    "critical_calls":    ["gf_strdup", "memcpy"]
+  },
+  "detection_plan": {
+    "bug_pattern":         "High-level description of the vulnerability pattern (e.g. 'heap buffer overflow when reading variable-length data into a fixed-size stack buffer without size bound')",
+    "report_condition":    "When should the checker emit a warning? (e.g. 'call to gf_strdup where the argument originates from a fixed-size local array that was populated by variable-length bitstream reads')",
+    "safe_condition":      "When should the checker NOT emit a warning? (e.g. 'argument originates from a heap allocation or a size-bounded source')",
+    "source_level_signal": "What AST / MemRegion / SVal property does the checker look for? (e.g. 'MemRegion extent < parameter size at a PreCall to gf_strdup')"
+  },
+  "api_choice": {
+    "mechanism_level":          "syntactic_ast | control_flow | path_sensitive | interprocedural_dataflow",
+    "callback":                 "check::PreCall | check::PostCall | check::PreStmt | check::PostStmt | check::Bind | check::DeadSymbols | check::EndFunction | ...",
+    "reasoning":                "Why this callback and its AST/state/CFG evidence prove the report and safe conditions",
+    "alternatives_considered":  ["check::PostCall"]
+  },
+  "implementation": {
+    "scope_level":    "patch_specific | project_general | cross_project",
+    "checker_name":   "project.CheckerName",
+    "build_attempts": 1
+  }
+}
+```
+
+### ``summary.json``
+
+```json
+{
+  "status":           "plausible | failed",
+  "bug_pattern":      "One sentence describing the bug pattern",
+  "scope_level":      "patch_specific | project_general | cross_project",
+  "checker_cpp":      "checker.cpp",
+  "checker_so":       "checker.so",
+  "n_buggy":          0,
+  "n_patched":        0,
+  "total_reports":    0,
+  "fp_rate_estimate": 0.0,
+  "failure_reason":   null
+}
+```

tasks/csa159/pair_164920/checker_template.cpp

@@ -0,0 +1,98 @@
+// ============================================================================
+// CSA Checker Template
+// ============================================================================
+// Fill in the sections marked with TODO to implement your checker.
+// The checker is compiled with -fno-rtti to match the LLVM 18 build config.
+// It is loaded via: clang -cc1 -load checker.so -analyzer-checker=your.CheckerName
+//
+// Compilation:
+//   clang++ -std=c++17 -fPIC -shared -fno-rtti -fno-exceptions \
+//           -I${LLVM_BUILD_DIR}/include \
+//           checker.cpp -o checker.so \
+//           -Wl,--allow-shlib-undefined
+//
+// Usage:
+//   clang -cc1 -load ./checker.so -analyzer-checker=your.CheckerName -analyze <file>
+// ============================================================================
+
+#include "clang/StaticAnalyzer/Core/BugReporter/BugReporter.h"
+#include "clang/StaticAnalyzer/Core/BugReporter/BugType.h"
+#include "clang/StaticAnalyzer/Core/Checker.h"
+#include "clang/StaticAnalyzer/Core/PathSensitive/CallEvent.h"
+#include "clang/StaticAnalyzer/Core/PathSensitive/CheckerContext.h"
+#include "clang/StaticAnalyzer/Frontend/CheckerRegistry.h"
+
+using namespace clang;
+using namespace ento;
+
+namespace {
+
+// ────────────────────────────────────────────────────────────────
+// TODO: Rename this class to describe your checker's purpose.
+// ────────────────────────────────────────────────────────────────
+class {{CHECKER_CLASS_NAME}}
+    : public Checker<check::PreCall,      // for checking before function calls
+                     check::PostCall>     // for checking after function calls
+{
+  // TODO: Customize the bug type name and category.
+  mutable std::unique_ptr<BugType> BT;
+
+public:
+  {{CHECKER_CLASS_NAME}}()
+      : BT(new BugType(this, "{{BUG_NAME}}", "{{BUG_CATEGORY}}")) {}
+
+  // ── PreCall callback (fires before every function call) ──────
+  void checkPreCall(const CallEvent &Call, CheckerContext &C) const {
+    // TODO: Implement your pre-call analysis logic here.
+    //
+    // Common patterns:
+    //
+    // 1. Check if the called function matches a specific name:
+    //    if (Call.getCalleeIdentifier()) {
+    //      StringRef name = Call.getCalleeIdentifier()->getName();
+    //      if (name == "target_function") { ... }
+    //    }
+    //
+    // 2. Get the program state:
+    //    ProgramStateRef State = C.getState();
+    //
+    // 3. Get arguments:
+    //    SVal Arg = Call.getArgSVal(0);
+    //
+    // 4. Generate a bug report:
+    //    ExplodedNode *ErrNode = C.generateErrorNode();
+    //    if (ErrNode) {
+    //      auto R = std::make_unique<PathSensitiveBugReport>(
+    //          *BT, "Description of the bug", ErrNode);
+    //      C.emitReport(std::move(R));
+    //    }
+  }
+
+  // ── PostCall callback (fires after every function call) ─────
+  void checkPostCall(const CallEvent &Call, CheckerContext &C) const {
+    // TODO: Implement your post-call analysis logic here.
+    //
+    // Common pattern — check the return value:
+    //   SVal RetVal = Call.getReturnValue();
+    //   if (RetVal.isUnknownOrUndef()) return;
+    //
+    //   ProgramStateRef State = C.getState();
+    //   // Modify state based on post-call conditions...
+  }
+};
+
+} // anonymous namespace
+
+// ────────────────────────────────────────────────────────────────
+// Registration — DO NOT modify the function signatures.
+// ────────────────────────────────────────────────────────────────
+
+extern "C" void clang_registerCheckers(CheckerRegistry &registry) {
+  registry.addChecker<{{CHECKER_CLASS_NAME}}>(
+      "{{CHECKER_FULL_NAME}}",  // e.g., "your.NullDereferenceChecker"
+      "{{CHECKER_DESC}}",       // e.g., "Detects null pointer dereference"
+      "{{CHECKER_DOC_URI}}");   // e.g., "https://example.com/docs"
+}
+
+extern "C" const char clang_analyzerAPIVersionString[] =
+    CLANG_ANALYZER_API_VERSION_STRING;

tasks/csa159/pair_164920/config.json

@@ -0,0 +1,19 @@
+{
+  "project_id": "torvalds_linux",
+  "before_commit": "a47c397bb29fce1751dc755246a2c8deeca5e38f",
+  "after_commit": "7a6b1ab7475fd6478eeaf5c9d1163e7a18125c8f",
+  "repo_path": "/workspace/repo/torvalds/linux",
+  "llvm_build_dir": "/opt/llvm",
+  "before_compile_commands": "/workspace/benchmark/data-pipeline/snapshots/torvalds_linux/c4681547bcce777daf576925a966ffa824edd09d/compile_commands.json",
+  "after_compile_commands": "/workspace/benchmark/data-pipeline/snapshots/torvalds_linux/c4681547bcce777daf576925a966ffa824edd09d/compile_commands.json",
+  "changed_files": [
+    "net/core/neighbour.c"
+  ],
+  "commit_message": "neighbour: allow NUD_NOARP entries to be forced GCed\n\nIFF_POINTOPOINT interfaces use NUD_NOARP entries for IPv6. It's possible to\nfill up the neighbour table with enough entries that it will overflow for\nvalid connections after that.\n\nThis behaviour is more prevalent after commit 58956317c8de (\"neighbor:\nImprove garbage collection\") is applied, as it prevents removal from\nentries that are not NUD_FAILED, unless they are more than 5s old.\n\nFixes: 58956317c8de (neighbor: Improve garbage collection)\nReported-by: Kasper Dupont <kasperd@gjkwv.06.feb.2021.kasperd.net>\nSigned-off-by: Thadeu Lima de Souza Cascardo <cascardo@canonical.com>\nSigned-off-by: David Ahern <dsahern@kernel.org>\nSigned-off-by: David S. Miller <davem@davemloft.net>",
+  "t_valid": 50,
+  "t_plausible": 20,
+  "triage_sample_size": 10,
+  "max_synthesis_retry": 0,
+  "max_in_session_redesigns": 1,
+  "max_refinement_iter": 3
+}

tasks/csa159/pair_164920/patch.diff

@@ -0,0 +1,12 @@
+diff --git a/net/core/neighbour.c b/net/core/neighbour.c
+index 98f20efbfadf..bf774575ad71 100644
+--- a/net/core/neighbour.c
++++ b/net/core/neighbour.c
+@@ -238,6 +238,7 @@ static int neigh_forced_gc(struct neigh_table *tbl)
+ 
+ 			write_lock(&n->lock);
+ 			if ((n->nud_state == NUD_FAILED) ||
++			    (n->nud_state == NUD_NOARP) ||
+ 			    (tbl->is_multicast &&
+ 			     tbl->is_multicast(n->primary_key)) ||
+ 			    time_after(tref, n->updated))

tasks/csa159/pair_164920/post_functions.txt

@@ -0,0 +1,40 @@
+### File: net/core/neighbour.c
+```c
+static int neigh_forced_gc(struct neigh_table *tbl)
+{
+	int max_clean = atomic_read(&tbl->gc_entries) - tbl->gc_thresh2;
+	unsigned long tref = jiffies - 5 * HZ;
+	struct neighbour *n, *tmp;
+	int shrunk = 0;
+
+	NEIGH_CACHE_STAT_INC(tbl, forced_gc_runs);
+
+	write_lock_bh(&tbl->lock);
+
+	list_for_each_entry_safe(n, tmp, &tbl->gc_list, gc_list) {
+		if (refcount_read(&n->refcnt) == 1) {
+			bool remove = false;
+
+			write_lock(&n->lock);
+			if ((n->nud_state == NUD_FAILED) ||
+			    (n->nud_state == NUD_NOARP) ||
+			    (tbl->is_multicast &&
+			     tbl->is_multicast(n->primary_key)) ||
+			    time_after(tref, n->updated))
+				remove = true;
+			write_unlock(&n->lock);
+
+			if (remove && neigh_remove_one(n, tbl))
+				shrunk++;
+			if (shrunk >= max_clean)
+				break;
+		}
+	}
+
+	tbl->last_flush = jiffies;
+
+	write_unlock_bh(&tbl->lock);
+
+	return shrunk;
+}
+```

tasks/csa159/pair_164920/pre_functions.txt

@@ -0,0 +1,39 @@
+### File: net/core/neighbour.c
+```c
+static int neigh_forced_gc(struct neigh_table *tbl)
+{
+	int max_clean = atomic_read(&tbl->gc_entries) - tbl->gc_thresh2;
+	unsigned long tref = jiffies - 5 * HZ;
+	struct neighbour *n, *tmp;
+	int shrunk = 0;
+
+	NEIGH_CACHE_STAT_INC(tbl, forced_gc_runs);
+
+	write_lock_bh(&tbl->lock);
+
+	list_for_each_entry_safe(n, tmp, &tbl->gc_list, gc_list) {
+		if (refcount_read(&n->refcnt) == 1) {
+			bool remove = false;
+
+			write_lock(&n->lock);
+			if ((n->nud_state == NUD_FAILED) ||
+			    (tbl->is_multicast &&
+			     tbl->is_multicast(n->primary_key)) ||
+			    time_after(tref, n->updated))
+				remove = true;
+			write_unlock(&n->lock);
+
+			if (remove && neigh_remove_one(n, tbl))
+				shrunk++;
+			if (shrunk >= max_clean)
+				break;
+		}
+	}
+
+	tbl->last_flush = jiffies;
+
+	write_unlock_bh(&tbl->lock);
+
+	return shrunk;
+}
+```

tasks/csa159/pair_164920/task_prompt.md

@@ -0,0 +1,381 @@
+# Task: Synthesize a CSA Checker from a CVE Patch
+
+## Your Role
+
+You are a static analysis expert. Synthesize a Clang Static Analyzer (CSA) checker
+that detects the bug pattern fixed by the CVE patch in this working directory.
+
+You have full filesystem and bash access — use them.
+
+### Skills
+
+Many skills are available under `.claude/skills/` — covering vulnerability analysis,
+checker design, debugging, code audit, security patterns, and more.  Each skill
+encodes reusable expertise: take time to explore them, read their SKILL.md files,
+and invoke those that look useful via the Skill tool.  Let the task guide which
+ones you reach for.
+
+## File Layout
+
+```
+/work/
+├── compile.sh               ← RUN ME: compile checker.cpp → checker.so
+├── checker_template.cpp     ← skeleton, start here
+├── patch.diff               ← the CVE fix
+├── pre_functions.txt        ← buggy source (before_commit)
+├── post_functions.txt       ← patched source (after_commit)
+├── config.json              ← paths, commit_message, commit hashes, flags
+├── scan/
+│   ├── scan_before.sh       ← RUN ME: scan before_commit → N_buggy
+│   ├── scan_after.sh        ← RUN ME: scan after_commit → N_patched
+│   └── flags_*.txt          ← pre-extracted compile flags (-I, -D)
+├── references/
+│   ├── repo_knowledge.md            ← project-specific API/convention reference
+│   ├── patterns_summary.md       ← (optional) historical bug pattern summary
+│   ├── cwe_cards/                ← CWE knowledge library (all categories)
+│   │   ├── index.json             ← lookup index — use to find relevant cards
+│   │   ├── CWE-{id}(-variant).md  ← Tier 1/2 per-CWE detection patterns
+│   │   ├── Category-{name}.md     ← Tier 3 umbrella cards (rare CWEs grouped)
+│   ├── csa_headers_api.md   ← API quick reference (extracted from LLVM 18 headers)
+│   ├── csa_checker_patterns.md ← pattern catalog (resource tracking, null check, etc.)
+│   ├── csa_utility_functions.h ← copy-paste C++ helpers for checker.cpp (AST traversal, expression eval, etc.)
+│   └── examples/
+│       └── llvm-official/   ← 5 official checker sources (with comments)
+│           ├── 01_div_zero.cpp
+│           ├── 02_simple_stream.cpp
+│           ├── 03_undef_result.cpp
+│           ├── 04_nullability.cpp
+│           └── 05_malloc.cpp
+│
+├── checker.cpp              ← YOUR OUTPUT: synthesized checker
+├── checker.so               ← YOUR OUTPUT: compiled checker
+├── state.json               ← YOUR OUTPUT: structured task state
+├── scope_statement.md       ← YOUR OUTPUT: checker scope analysis (Level 1/2/3)
+└── summary.json             ← YOUR OUTPUT: final report
+```
+
+## Resources
+
+**Read these before writing any code:**
+
+1. **`references/csa_headers_api.md`** — CSA API quick reference. Extracted directly from
+   LLVM 18 headers. Covers all checker callbacks, ProgramState operations, SVal types,
+   MemRegion hierarchy, and bug reporting. **Read this first whenever you need API info.**
+
+2. **`references/csa_checker_patterns.md`** — Pattern catalog. Documents 5 battle-tested
+   patterns from official LLVM checkers: resource tracking, null checking, undefined
+   value detection, division-by-zero, and malloc/free. Each pattern includes skeleton
+   code, state traits, and key API usage.
+
+3. **`references/examples/llvm-official/`** — 5 official LLVM 18 checker implementations
+   with explanatory comments:
+   - `01_div_zero.cpp` — simplest checker (169 lines, 1 callback)
+   - `02_simple_stream.cpp` — resource tracking (292 lines, fopen/fclose)
+   - `03_undef_result.cpp` — PostStmt pattern (160 lines)
+   - `04_nullability.cpp` — multi-callback checker (1247 lines)
+   - `05_malloc.cpp` — comprehensive malloc/free (1511 lines)
+
+4. **`checker_template.cpp`** — Skeleton with placeholders. Start here.
+
+5. **`references/repo_knowledge.md`** — Project-specific reference. Contains this
+   repository's memory allocation API, key data types, source layout, and typical
+   CVE patterns. **Read this before writing the checker** — knowing the project's
+   alloc/free conventions and common bug patterns saves many grep rounds.
+
+5b. **`references/patterns_summary.md`** — (may not exist) Historical synthesis
+   patterns for this project.  If present, it contains a concise summary of the
+   most common bug patterns, frequent CWE categories, and reusable checker
+   architectures observed in previous synthesis runs.  Read after repo_knowledge.md.
+
+6. **`references/cwe_cards/`** — Complete CWE knowledge base covering all
+   vulnerability categories.  **The framework provides the full library —
+   you must identify the vulnerability type yourself.**  Workflow:
+
+   1. Analyse the patch diff and commit message to determine the vulnerability
+      type (buffer overflow, UAF, null deref, integer overflow, race condition,
+      etc.).  Do NOT rely on the CWE label — treat it as a hint at most.
+   2. Open ``index.json`` to discover available cards and their tiers.
+   3. Read the relevant card(s) for **detection strategies**, **checker
+      architecture suggestions**, and **known false-positive patterns**.
+
+   Card tiers:
+   - ``CWE-{id}(-{variant}).md`` — Tier 1/2 cards for common CWEs; kernel /
+     userspace variants when the detection strategy differs substantially.
+   - ``Category-{name}.md`` — Tier 3 umbrella cards grouping rarer CWEs by
+     category (input validation, resource management, etc.).
+
+7. **`references/csa_utility_functions.h`** — Copy-paste C++ helper functions for
+   checker.cpp. Includes AST traversal (`findSpecificTypeInParents/Children`),
+   expression evaluation (`EvaluateExprToInt`, `inferSymbolMaxVal`), array/string
+   size extraction, MemRegion helpers, and `ExprHasName()` for robust function
+   matching. All verified against LLVM 18. **Read before implementing detection
+   logic** — these save writing boilerplate that's easy to get wrong.
+
+## Environment
+
+Key paths are in ``config.json``.
+
+### Pre-built scripts
+
+| Script | What it does |
+|--------|-------------|
+| `bash compile.sh` | Compile checker.cpp → checker.so (with correct flags) |
+| `CHECKER_NAME=<name> bash scan/scan_before.sh` | Scan before_commit, count warnings → N_buggy |
+| `CHECKER_NAME=<name> bash scan/scan_after.sh` | Scan after_commit, count warnings → N_patched |
+
+```bash
+# Compile (run from workdir root)
+bash compile.sh
+
+# Scan — set CHECKER_NAME to the string passed to addChecker<>()
+CHECKER_NAME=your.CheckerName bash scan/scan_before.sh   # → N_buggy
+CHECKER_NAME=your.CheckerName bash scan/scan_after.sh    # → N_patched
+```
+
+- ``compile.sh`` already has the correct ``-I`` / ``-fno-rtti`` flags.
+- ``scan/scan_*.sh`` count only warnings tagged with your checker name.
+- Scan environments (source files + compile flags) are pre-built in ``scan/``.
+
+### Scan Script Integrity (CRITICAL)
+
+The scan scripts (``scan/scan_before.sh``, ``scan/scan_after.sh``) are the **only
+valid measurement** of N_buggy and N_patched.  They are the ground truth that the
+Python-side validator will also use.  You MUST obey these rules:
+
+**1. Never bypass the scan scripts.**  Do NOT run ``clang --analyze`` directly
+   to measure warning counts.  The Python validator runs the same scan scripts
+   — if you measured with a different command, your numbers will not reproduce
+   and the synthesis will be rejected.
+
+**2. If the scan script prints COMPILE_ERROR** (missing headers, undeclared
+   identifiers, etc.), the scan environment needs repair.  You MUST fix it:
+   - Add missing ``-I`` include paths to the flags files in ``scan/``
+   - Copy needed generated headers (e.g. ``autoconf.h``) from the snapshot
+   - If the file fundamentally cannot be compiled by clang, stop and write
+     ``summary.json`` with ``status: "failed"`` and an honest ``failure_reason``
+
+**3. Only trust scan script output.**  The ``Total <name> warnings: N`` line
+   printed by the scan script is the number that goes into ``summary.json``.
+   If the scan script says 0, write 0.  Fabricating numbers that the scan
+   script did not produce will cause the Python validator to reject the
+   synthesis.
+
+- If compile fails: read the error, fix ``checker.cpp``, retry (max 3 cycles).
+- If validation fails: revise checker logic, re-compile, re-scan.
+
+## MCP Tools
+
+You have access to 3 MCP tools under the `csa-tools` server (prefixed `mcp__csa-tools__`).
+Each returns **source context embedded in the result** — no need to follow up with Read.
+
+| Tool | What it does | Key advantage |
+|------|-------------|---------------|
+| `search(pattern, scope)` | Search for a pattern in source / LLVM headers / workdir | Returns file:line + 3 lines context — grep + Read in one call |
+| `compile()` | Run compile.sh, return parsed diagnostics | Errors include checker.cpp context — fix without reading the file |
+| `scan(checker_name)` | Run before/after scan, return N_buggy + N_patched + warning locations | Each warning includes source context — no manual clang --analyze needed |
+
+### When to use each
+
+- **`search`**: Whenever you would type `grep -rn "X"` or `find ... -name`. Use `scope="source"` for CVE code, `scope="llvm"` for CSA API headers, `scope="all"` when unsure.
+- **`compile`**: Instead of `bash compile.sh` followed by reading checker.cpp at error lines.
+- **`scan`**: Instead of running scan_before.sh + scan_after.sh + manual clang inspection. Returns everything you need to decide next action.
+
+## Semantic Design Contract — before writing checker.cpp
+
+Create the analysis portions of `state.json` and `scope_statement.md` **before**
+writing checker.cpp. They are a design contract, not a retrospective summary.
+After compilation, update only implementation facts such as `build_attempts`.
+
+In `patch_analysis`, distinguish the vulnerable operation, its trigger, and the
+semantic fact introduced by the patch that makes it safe. In `detection_plan`,
+make `report_condition`, `safe_condition`, and `source_level_signal` concrete
+CSA-observable facts. In `api_choice`, record the mechanism level and explain
+why the selected callback can observe and prove those facts.
+
+In `scope_statement.md`, include this mapping table and check it again after
+implementation:
+
+| Semantic condition | CSA evidence | checker.cpp implementation |
+| --- | --- | --- |
+| report condition | AST / SVal / MemRegion / CFG evidence | callback, helper, and branch that reports |
+| safe condition | path constraint, guard, state discharge, or structural fact | branch that suppresses the report |
+
+Every condition in the plan must have an implementation entry. Do not claim a
+condition that checker.cpp does not implement, and do not silently add a code
+condition absent from the plan.
+
+## Mechanism Selection — diagnose before coding
+
+Choose the weakest CSA mechanism that can prove the vulnerability property:
+
+1. **syntax-only AST**: only when local AST shape itself is the defect;
+2. **control flow / dominance**: when guard placement relative to a sink matters;
+3. **path-sensitive ProgramState/SVal**: when an unsafe state must reach a use;
+4. **cross-procedure/dataflow**: when the required fact crosses function boundaries.
+
+For a guard-based patch, prove both that the guard rejects the unsafe value and
+that it dominates the vulnerable use. For path-sensitive or cross-procedure
+defects, do not replace the required state or flow proof with local AST matching
+or source-text substring matching merely because it passes the differential scan.
+Record the selected level as `api_choice.mechanism_level`.
+
+## Semantic identity, locality, and final validation
+
+Before accepting the checker, verify that its primary matching logic does not
+depend on patch-local variable names, labels, line numbers, commit IDs, or unique
+literals. Project APIs, types, and stable semantic call relationships are valid
+scope anchors when they define the vulnerability class. Attach the report to the
+actual vulnerable operation, and implement every suppression as a real safe
+condition rather than the mere presence of a nearby guard-shaped statement.
+
+The required final sequence is: **compile → before scan → after scan → inspect
+the final checker name, artifacts, and report locations → write summary.json**.
+Always run the final compile and both scans. `MAX_IN_SESSION_REDESIGNS` limits only
+additional redesign cycles after a failed validation; if it is zero, preserve the
+real validation evidence and report failure honestly rather than fabricating counts.
+
+## Validation Criteria
+
+```
+VALID   : N_buggy > N_patched  AND  N_patched < 50
+INVALID : otherwise → revise and re-validate (max 1 attempts)
+```
+
+## Refinement
+
+Do NOT self-refine the checker repeatedly. Your goal is to produce the first
+checker that passes the Validation Criteria above — fix compile errors and
+validation failures only. False positives are triaged and repaired by the
+framework's refinement stage: you will receive a concrete FP list via
+session resume (if needed) and fix only those. Reserve budget for that stage.
+
+## Output
+
+Produce all of the following **only when completely done**:
+
+| File | Content |
+|------|---------|
+| ``checker.cpp`` | Synthesized checker source code |
+| ``checker.so`` | Compiled checker plugin |
+| ``state.json`` | Structured task state (see schema below) |
+| ``scope_statement.md`` | Checker scope analysis in prose (Level 1/2/3) |
+| ``summary.json`` | Final report (see schema below) |
+
+Writing ``summary.json`` signals completion.  Do NOT write it early.
+
+### ``state.json``
+
+Create this before writing checker.cpp to capture the design contract. After the
+checker compiles, update only implementation facts and retain the original
+semantic plan.
+
+```json
+{
+  "patch_analysis": {
+    "summary":           "One sentence describing the vulnerability this patch fixes",
+    "changed_files":     ["file1.c", "file2.h"],
+    "changed_functions": ["func_a", "func_b"],
+    "bug_type":          "buffer_overflow | use_after_free | null_deref | integer_overflow | race_condition | resource_leak | double_free | input_validation | other",
+    "fix_strategy":      "add_bounds_check | add_null_check | add_size_check | add_early_return | reorder_operations | change_api_signature | other",
+    "affected_types":    ["GF_BitStream", "custom_struct_t"],
+    "critical_calls":    ["gf_strdup", "memcpy"]
+  },
+  "detection_plan": {
+    "bug_pattern":         "High-level description of the vulnerability pattern (e.g. 'heap buffer overflow when reading variable-length data into a fixed-size stack buffer without size bound')",
+    "report_condition":    "When should the checker emit a warning? (e.g. 'call to gf_strdup where the argument originates from a fixed-size local array that was populated by variable-length bitstream reads')",
+    "safe_condition":      "When should the checker NOT emit a warning? (e.g. 'argument originates from a heap allocation or a size-bounded source')",
+    "source_level_signal": "What AST / MemRegion / SVal property does the checker look for? (e.g. 'MemRegion extent < parameter size at a PreCall to gf_strdup')"
+  },
+  "api_choice": {
+    "mechanism_level":          "syntactic_ast | control_flow | path_sensitive | interprocedural_dataflow",
+    "callback":                 "check::PreCall | check::PostCall | check::PreStmt | check::PostStmt | check::Bind | check::DeadSymbols | check::EndFunction | ...",
+    "reasoning":                "Why this callback and its AST/state/CFG evidence prove the report and safe conditions",
+    "alternatives_considered":  ["check::PostCall"]
+  },
+  "implementation": {
+    "scope_level":    "patch_specific | project_general | cross_project",
+    "checker_name":   "project.CheckerName",
+    "build_attempts": 1
+  }
+}
+```
+
+### ``summary.json``
+
+```json
+{
+  "status":           "plausible | failed",
+  "bug_pattern":      "One sentence describing the bug pattern",
+  "scope_level":      "patch_specific | project_general | cross_project",
+  "checker_cpp":      "checker.cpp",
+  "checker_so":       "checker.so",
+  "n_buggy":          0,
+  "n_patched":        0,
+  "total_reports":    0,
+  "fp_rate_estimate": 0.0,
+  "failure_reason":   null
+}
+```
+
+## Feedback-derived requirements for this fresh synthesis
+
+A prior independent rollout exposed the risks below. Start again from the patch
+in this new session. Do not reconstruct, edit, or assume the prior checker.
+
+Required mechanism level: `control_flow`
+
+### Current failure diagnosis
+
+- The rollout failed the process-quality and hardcoding-free checks because the design embedded patch-specific context and did not provide a sufficiently general, rigorous implementation argument.
+- Lexical parent lookup was treated as domination, while a whole-function AST scan collected assignments without proving that they reach the reclamation sink, occur before it, or define the guard value used there.
+- The safety test was polarity-insensitive: `nud_state != NUD_NOARP`, negated tests, and arbitrary bit tests could suppress a report even though they exclude rather than admit NUD_NOARP.
+- The analysis did not prove that the state predicate, flag definition, guard, and `neigh_remove_one` argument concern the same neighbour object.
+- The stated consequence was overstated because multicast and age alternatives can still permit removal; the defect is absence of state-based eligibility for NUD_NOARP when the other alternatives are false.
+
+### Preserve from prior rollouts
+
+- The synthesized checker must compile successfully against the supplied CSA environment.
+- Preserve successful differential validation: diagnostics must occur on the vulnerable source and disappear on the patched source.
+- Preserve code verification and objective eligibility gate G6.
+- Preserve an accepted or clean refinement outcome.
+- Retain at least the previously adequate semantic score and CSA mechanism capability.
+- Remain independent of patch anchors such as changed line numbers or diff locations.
+
+### Required semantic proof
+
+- Identify a reclamation call whose execution is control-dependent on a local eligibility value derived from predicates over a neighbour object's `nud_state`.
+- Use CFG ordering and reaching-definition relationships to connect only definitions that can reach the sink guard before the sink; unrelated, overwritten, unreachable, or later assignments must not affect the result.
+- Prove object identity between the neighbour passed to reclamation and the neighbour whose state is tested, accounting for casts and equivalent expression forms without conflating different objects.
+- Interpret predicate polarity and Boolean structure so that only a positively effective NUD_NOARP alternative counts as coverage; inequality, negation, or a test on an excluding branch is not safe.
+- Report when setting the relevant object to NUD_NOARP, with independent multicast and age alternatives false, cannot make the sink eligible through the state predicate.
+- Suppress when a reachable definition governing the sink positively admits NUD_NOARP for that same object, as in the added equality disjunct.
+
+### Implementation constraints
+
+- Use a CSA callback that permits one enclosing-function analysis, such as `check::ASTCodeBody`, or a call callback paired with the enclosing `AnalysisDeclContext` CFG; do not rely solely on lexical ParentMap ancestry.
+- Build explicit CFG control-dependence, dominance, statement-order, and reaching-definition checks between the eligibility definition, guard, and reclamation sink without introducing ProgramState tracking.
+- Normalize relevant Boolean expressions through parentheses, implicit casts, logical operators, and unary negation before deciding whether NUD_NOARP is admitted or excluded.
+- Resolve the state member, NUD_NOARP declaration/value, sink callee, flag declarations, and sink argument through AST declarations and expression identity rather than source-text matching.
+- Emit one diagnostic at the controlling eligibility predicate or guarded reclamation operation, with a source range local to the proven relation.
+- Keep scope project-general within neighbour reclamation semantics; do not restrict matching to `neigh_forced_gc`, a local variable name such as `remove`, a source path, a commit identifier, or a line number.
+- Do not encode the patch as an exact token sequence or use the numeric value `0x40` as a substitute for establishing the NUD_NOARP semantic declaration.
+
+### Validation checklist
+
+- Compile the checker plugin and verify registration and loading with the supplied Clang Static Analyzer.
+- Scan both supplied vulnerable inputs and confirm relevant diagnostics in `neigh_forced_gc`; scan both patched inputs and confirm zero diagnostics.
+- Confirm diagnostics remain within the changed function and near the eligibility predicate or its guarded `neigh_remove_one` sink, with no warnings in non-patched functions.
+- Verify that unconditional or state-independent `neigh_remove_one` calls are suppressed.
+- Add refinements showing that positive `nud_state == NUD_NOARP` coverage suppresses while `nud_state != NUD_NOARP`, negated equality, and excluding branches do not.
+- Add refinements with unrelated objects, assignments after the sink, unreachable assignments, and overwritten flag definitions; none may falsely establish safety.
+- Add a refinement where NUD_NOARP coverage reaches the sink through an equivalent positively oriented guard and confirm suppression without requiring the exact patch spelling.
+- Run code verification, differential cross-validation, hardcoding detection, and refinement evaluation, requiring G6 and an accepted or clean outcome.
+
+### Avoid and forbidden regressions
+
+- Do not reuse the failed lexical-parent plus unrestricted whole-function assignment scan as a substitute for CFG proof.
+- Do not treat the mere presence of any NUD_NOARP comparison anywhere in the function as evidence that reclamation accepts that state.
+- Do not classify inequality, polarity-reversed expressions, or arbitrary bitwise occurrence as a safe NUD_NOARP admission.
+- Do not assume every NUD_NOARP entry is unconditionally unreclaimable; phrase the finding around missing state-based eligibility and resulting retention when other alternatives are false.
+- Do not add path-sensitive ProgramState or interprocedural propagation when intraprocedural CFG analysis establishes the required relation.
+- Do not embed patch prose, commit metadata, source locations, changed-function identity, or exact patched syntax in matching logic or checker-facing implementation metadata.

tasks/csa159/pair_164974/checker_template.cpp

@@ -0,0 +1,98 @@
+// ============================================================================
+// CSA Checker Template
+// ============================================================================
+// Fill in the sections marked with TODO to implement your checker.
+// The checker is compiled with -fno-rtti to match the LLVM 18 build config.
+// It is loaded via: clang -cc1 -load checker.so -analyzer-checker=your.CheckerName
+//
+// Compilation:
+//   clang++ -std=c++17 -fPIC -shared -fno-rtti -fno-exceptions \
+//           -I${LLVM_BUILD_DIR}/include \
+//           checker.cpp -o checker.so \
+//           -Wl,--allow-shlib-undefined
+//
+// Usage:
+//   clang -cc1 -load ./checker.so -analyzer-checker=your.CheckerName -analyze <file>
+// ============================================================================
+
+#include "clang/StaticAnalyzer/Core/BugReporter/BugReporter.h"
+#include "clang/StaticAnalyzer/Core/BugReporter/BugType.h"
+#include "clang/StaticAnalyzer/Core/Checker.h"
+#include "clang/StaticAnalyzer/Core/PathSensitive/CallEvent.h"
+#include "clang/StaticAnalyzer/Core/PathSensitive/CheckerContext.h"
+#include "clang/StaticAnalyzer/Frontend/CheckerRegistry.h"
+
+using namespace clang;
+using namespace ento;
+
+namespace {
+
+// ────────────────────────────────────────────────────────────────
+// TODO: Rename this class to describe your checker's purpose.
+// ────────────────────────────────────────────────────────────────
+class {{CHECKER_CLASS_NAME}}
+    : public Checker<check::PreCall,      // for checking before function calls
+                     check::PostCall>     // for checking after function calls
+{
+  // TODO: Customize the bug type name and category.
+  mutable std::unique_ptr<BugType> BT;
+
+public:
+  {{CHECKER_CLASS_NAME}}()
+      : BT(new BugType(this, "{{BUG_NAME}}", "{{BUG_CATEGORY}}")) {}
+
+  // ── PreCall callback (fires before every function call) ──────
+  void checkPreCall(const CallEvent &Call, CheckerContext &C) const {
+    // TODO: Implement your pre-call analysis logic here.
+    //
+    // Common patterns:
+    //
+    // 1. Check if the called function matches a specific name:
+    //    if (Call.getCalleeIdentifier()) {
+    //      StringRef name = Call.getCalleeIdentifier()->getName();
+    //      if (name == "target_function") { ... }
+    //    }
+    //
+    // 2. Get the program state:
+    //    ProgramStateRef State = C.getState();
+    //
+    // 3. Get arguments:
+    //    SVal Arg = Call.getArgSVal(0);
+    //
+    // 4. Generate a bug report:
+    //    ExplodedNode *ErrNode = C.generateErrorNode();
+    //    if (ErrNode) {
+    //      auto R = std::make_unique<PathSensitiveBugReport>(
+    //          *BT, "Description of the bug", ErrNode);
+    //      C.emitReport(std::move(R));
+    //    }
+  }
+
+  // ── PostCall callback (fires after every function call) ─────
+  void checkPostCall(const CallEvent &Call, CheckerContext &C) const {
+    // TODO: Implement your post-call analysis logic here.
+    //
+    // Common pattern — check the return value:
+    //   SVal RetVal = Call.getReturnValue();
+    //   if (RetVal.isUnknownOrUndef()) return;
+    //
+    //   ProgramStateRef State = C.getState();
+    //   // Modify state based on post-call conditions...
+  }
+};
+
+} // anonymous namespace
+
+// ────────────────────────────────────────────────────────────────
+// Registration — DO NOT modify the function signatures.
+// ────────────────────────────────────────────────────────────────
+
+extern "C" void clang_registerCheckers(CheckerRegistry &registry) {
+  registry.addChecker<{{CHECKER_CLASS_NAME}}>(
+      "{{CHECKER_FULL_NAME}}",  // e.g., "your.NullDereferenceChecker"
+      "{{CHECKER_DESC}}",       // e.g., "Detects null pointer dereference"
+      "{{CHECKER_DOC_URI}}");   // e.g., "https://example.com/docs"
+}
+
+extern "C" const char clang_analyzerAPIVersionString[] =
+    CLANG_ANALYZER_API_VERSION_STRING;

tasks/csa159/pair_164974/config.json

@@ -0,0 +1,19 @@
+{
+  "project_id": "torvalds_linux",
+  "before_commit": "a902f3dec70a46332a8c99604de384fbabd734e5",
+  "after_commit": "31b62908693c90d4d07db597e685d9f25a120073",
+  "repo_path": "/workspace/repo/torvalds/linux",
+  "llvm_build_dir": "/opt/llvm",
+  "before_compile_commands": "/workspace/benchmark/data-pipeline/snapshots/torvalds_linux/610a9b8f49fbcf1100716370d3b5f6f884a2835a/compile_commands.json",
+  "after_compile_commands": "/workspace/benchmark/data-pipeline/snapshots/torvalds_linux/610a9b8f49fbcf1100716370d3b5f6f884a2835a/compile_commands.json",
+  "changed_files": [
+    "net/sunrpc/xprtmultipath.c"
+  ],
+  "commit_message": "SUNRPC: Fix a suspicious RCU usage warning\n\nI received the following warning while running cthon against an ontap\nserver running pNFS:\n\n[   57.202521] =============================\n[   57.202522] WARNING: suspicious RCU usage\n[   57.202523] 6.7.0-rc3-g2cc14f52aeb7 #41492 Not tainted\n[   57.202525] -----------------------------\n[   57.202525] net/sunrpc/xprtmultipath.c:349 RCU-list traversed in non-reader section!!\n[   57.202527]\n               other info that might help us debug this:\n\n[   57.202528]\n               rcu_scheduler_active = 2, debug_locks = 1\n[   57.202529] no locks held by test5/3567.\n[   57.202530]\n               stack backtrace:\n[   57.202532] CPU: 0 PID: 3567 Comm: test5 Not tainted 6.7.0-rc3-g2cc14f52aeb7 #41492 5b09971b4965c0aceba19f3eea324a4a806e227e\n[   57.202534] Hardware name: QEMU Standard PC (Q35 + ICH9, 2009), BIOS unknown 2/2/2022\n[   57.202536] Call Trace:\n[   57.202537]  <TASK>\n[   57.202540]  dump_stack_lvl+0x77/0xb0\n[   57.202551]  lockdep_rcu_suspicious+0x154/0x1a0\n[   57.202556]  rpc_xprt_switch_has_addr+0x17c/0x190 [sunrpc ebe02571b9a8ceebf7d98e71675af20c19bdb1f6]\n[   57.202596]  rpc_clnt_setup_test_and_add_xprt+0x50/0x180 [sunrpc ebe02571b9a8ceebf7d98e71675af20c19bdb1f6]\n[   57.202621]  ? rpc_clnt_add_xprt+0x254/0x300 [sunrpc ebe02571b9a8ceebf7d98e71675af20c19bdb1f6]\n[   57.202646]  rpc_clnt_add_xprt+0x27a/0x300 [sunrpc ebe02571b9a8ceebf7d98e71675af20c19bdb1f6]\n[   57.202671]  ? __pfx_rpc_clnt_setup_test_and_add_xprt+0x10/0x10 [sunrpc ebe02571b9a8ceebf7d98e71675af20c19bdb1f6]\n[   57.202696]  nfs4_pnfs_ds_connect+0x345/0x760 [nfsv4 c716d88496ded0ea6d289bbea684fa996f9b57a9]\n[   57.202728]  ? __pfx_nfs4_test_session_trunk+0x10/0x10 [nfsv4 c716d88496ded0ea6d289bbea684fa996f9b57a9]\n[   57.202754]  nfs4_fl_prepare_ds+0x75/0xc0 [nfs_layout_nfsv41_files e3a4187f18ae8a27b630f9feae6831b584a9360a]\n[   57.202760]  filelayout_write_pagelist+0x4a/0x200 [nfs_layout_nfsv41_files e3a4187f18ae8a27b630f9feae6831b584a9360a]\n[   57.202765]  pnfs_generic_pg_writepages+0xbe/0x230 [nfsv4 c716d88496ded0ea6d289bbea684fa996f9b57a9]\n[   57.202788]  __nfs_pageio_add_request+0x3fd/0x520 [nfs 6c976fa593a7c2976f5a0aeb4965514a828e6902]\n[   57.202813]  nfs_pageio_add_request+0x18b/0x390 [nfs 6c976fa593a7c2976f5a0aeb4965514a828e6902]\n[   57.202831]  nfs_do_writepage+0x116/0x1e0 [nfs 6c976fa593a7c2976f5a0aeb4965514a828e6902]\n[   57.202849]  nfs_writepages_callback+0x13/0x30 [nfs 6c976fa593a7c2976f5a0aeb4965514a828e6902]\n[   57.202866]  write_cache_pages+0x265/0x450\n[   57.202870]  ? __pfx_nfs_writepages_callback+0x10/0x10 [nfs 6c976fa593a7c2976f5a0aeb4965514a828e6902]\n[   57.202891]  nfs_writepages+0x141/0x230 [nfs 6c976fa593a7c2976f5a0aeb4965514a828e6902]\n[   57.202913]  do_writepages+0xd2/0x230\n[   57.202917]  ? filemap_fdatawrite_wbc+0x5c/0x80\n[   57.202921]  filemap_fdatawrite_wbc+0x67/0x80\n[   57.202924]  filemap_write_and_wait_range+0xd9/0x170\n[   57.202930]  nfs_wb_all+0x49/0x180 [nfs 6c976fa593a7c2976f5a0aeb4965514a828e6902]\n[   57.202947]  nfs4_file_flush+0x72/0xb0 [nfsv4 c716d88496ded0ea6d289bbea684fa996f9b57a9]\n[   57.202969]  __se_sys_close+0x46/0xd0\n[   57.202972]  do_syscall_64+0x68/0x100\n[   57.202975]  ? do_syscall_64+0x77/0x100\n[   57.202976]  ? do_syscall_64+0x77/0x100\n[   57.202979]  entry_SYSCALL_64_after_hwframe+0x6e/0x76\n[   57.202982] RIP: 0033:0x7fe2b12e4a94\n[   57.202985] Code: 00 f7 d8 64 89 01 48 83 c8 ff c3 66 2e 0f 1f 84 00 00 00 00 00 90 f3 0f 1e fa 80 3d d5 18 0e 00 00 74 13 b8 03 00 00 00 0f 05 <48> 3d 00 f0 ff ff 77 44 c3 0f 1f 00 48 83 ec 18 89 7c 24 0c e8 c3\n[   57.202987] RSP: 002b:00007ffe857ddb38 EFLAGS: 00000202 ORIG_RAX: 0000000000000003\n[   57.202989] RAX: ffffffffffffffda RBX: 00007ffe857dfd68 RCX: 00007fe2b12e4a94\n[   57.202991] RDX: 0000000000002000 RSI: 00007ffe857ddc40 RDI: 0000000000000003\n[   57.202992] RBP: 00007ffe857dfc50 R08: 7fffffffffffffff R09: 0000000065650f49\n[   57.202993] R10: 00007fe2b11f8300 R11: 0000000000000202 R12: 0000000000000000\n[   57.202994] R13: 00007ffe857dfd80 R14: 00007fe2b1445000 R15: 0000000000000000\n[   57.202999]  </TASK>\n\nThe problem seems to be that two out of three callers aren't taking the\nrcu_read_lock() before calling the list_for_each_entry_rcu() function in\nrpc_xprt_switch_has_addr(). I fix this by having\nrpc_xprt_switch_has_addr() unconditionaly take the rcu_read_lock(),\nwhich is okay to do recursively in the case that the lock has already\nbeen taken by a caller.\n\nReviewed-by: Jeff Layton <jlayton@kernel.org>\nSigned-off-by: Anna Schumaker <Anna.Schumaker@Netapp.com>",
+  "t_valid": 50,
+  "t_plausible": 20,
+  "triage_sample_size": 10,
+  "max_synthesis_retry": 0,
+  "max_in_session_redesigns": 1,
+  "max_refinement_iter": 3
+}

tasks/csa159/pair_164974/patch.diff

@@ -0,0 +1,35 @@
+diff --git a/net/sunrpc/xprtmultipath.c b/net/sunrpc/xprtmultipath.c
+index 701250b305db..0706575d9392 100644
+--- a/net/sunrpc/xprtmultipath.c
++++ b/net/sunrpc/xprtmultipath.c
+@@ -336,8 +336,9 @@ struct rpc_xprt *xprt_iter_current_entry_offline(struct rpc_xprt_iter *xpi)
+ 			xprt_switch_find_current_entry_offline);
+ }
+ 
+-bool rpc_xprt_switch_has_addr(struct rpc_xprt_switch *xps,
+-			      const struct sockaddr *sap)
++static
++bool __rpc_xprt_switch_has_addr(struct rpc_xprt_switch *xps,
++				const struct sockaddr *sap)
+ {
+ 	struct list_head *head;
+ 	struct rpc_xprt *pos;
+@@ -356,6 +357,18 @@ bool rpc_xprt_switch_has_addr(struct rpc_xprt_switch *xps,
+ 	return false;
+ }
+ 
++bool rpc_xprt_switch_has_addr(struct rpc_xprt_switch *xps,
++			      const struct sockaddr *sap)
++{
++	bool res;
++
++	rcu_read_lock();
++	res = __rpc_xprt_switch_has_addr(xps, sap);
++	rcu_read_unlock();
++
++	return res;
++}
++
+ static
+ struct rpc_xprt *xprt_switch_find_next_entry(struct list_head *head,
+ 		const struct rpc_xprt *cur, bool check_active)

tasks/csa159/pair_164974/post_functions.txt

@@ -0,0 +1,43 @@
+### File: net/sunrpc/xprtmultipath.c
+```c
+static
+struct rpc_xprt *xprt_iter_current_entry_offline(struct rpc_xprt_iter *xpi)
+{
+	return _xprt_iter_current_entry(xpi,
+			xprt_switch_find_first_entry_offline,
+			xprt_switch_find_current_entry_offline);
+}
+
+static
+bool __rpc_xprt_switch_has_addr(struct rpc_xprt_switch *xps,
+				const struct sockaddr *sap)
+{
+	struct list_head *head;
+	struct rpc_xprt *pos;
+
+	if (xps == NULL || sap == NULL)
+		return false;
+
+	head = &xps->xps_xprt_list;
+	list_for_each_entry_rcu(pos, head, xprt_switch) {
+		if (rpc_cmp_addr_port(sap, (struct sockaddr *)&pos->addr)) {
+			pr_info("RPC:   addr %s already in xprt switch\n",
+				pos->address_strings[RPC_DISPLAY_ADDR]);
+			return true;
+		}
+	}
+	return false;
+}
+
+bool rpc_xprt_switch_has_addr(struct rpc_xprt_switch *xps,
+			      const struct sockaddr *sap)
+{
+	bool res;
+
+	rcu_read_lock();
+	res = __rpc_xprt_switch_has_addr(xps, sap);
+	rcu_read_unlock();
+
+	return res;
+}
+```

tasks/csa159/pair_164974/pre_functions.txt

@@ -0,0 +1,52 @@
+### File: net/sunrpc/xprtmultipath.c
+```c
+static
+struct rpc_xprt *xprt_iter_current_entry_offline(struct rpc_xprt_iter *xpi)
+{
+	return _xprt_iter_current_entry(xpi,
+			xprt_switch_find_first_entry_offline,
+			xprt_switch_find_current_entry_offline);
+}
+
+bool rpc_xprt_switch_has_addr(struct rpc_xprt_switch *xps,
+			      const struct sockaddr *sap)
+{
+	struct list_head *head;
+	struct rpc_xprt *pos;
+
+	if (xps == NULL || sap == NULL)
+		return false;
+
+	head = &xps->xps_xprt_list;
+	list_for_each_entry_rcu(pos, head, xprt_switch) {
+		if (rpc_cmp_addr_port(sap, (struct sockaddr *)&pos->addr)) {
+			pr_info("RPC:   addr %s already in xprt switch\n",
+				pos->address_strings[RPC_DISPLAY_ADDR]);
+			return true;
+		}
+	}
+	return false;
+}
+
+static
+struct rpc_xprt *xprt_switch_find_next_entry(struct list_head *head,
+		const struct rpc_xprt *cur, bool check_active)
+{
+	struct rpc_xprt *pos, *prev = NULL;
+	bool found = false;
+
+	list_for_each_entry_rcu(pos, head, xprt_switch) {
+		if (cur == prev)
+			found = true;
+		/* for request to return active transports return only
+		 * active, for request to return offline transports
+		 * return only offline
+		 */
+		if (found && ((check_active && xprt_is_active(pos)) ||
+			      (!check_active && !xprt_is_active(pos))))
+			return pos;
+		prev = pos;
+	}
+	return NULL;
+}
+```

tasks/csa159/pair_164974/task_prompt.md

@@ -0,0 +1,370 @@
+# Task: Synthesize a CSA Checker from a CVE Patch
+
+## Your Role
+
+You are a static analysis expert. Synthesize a Clang Static Analyzer (CSA) checker
+that detects the bug pattern fixed by the CVE patch in this working directory.
+
+You have full filesystem and bash access — use them.
+
+### Skills
+
+Many skills are available under `.claude/skills/` — covering vulnerability analysis,
+checker design, debugging, code audit, security patterns, and more.  Each skill
+encodes reusable expertise: take time to explore them, read their SKILL.md files,
+and invoke those that look useful via the Skill tool.  Let the task guide which
+ones you reach for.
+
+## File Layout
+
+```
+/work/
+├── compile.sh               ← RUN ME: compile checker.cpp → checker.so
+├── checker_template.cpp     ← skeleton, start here
+├── patch.diff               ← the CVE fix
+├── pre_functions.txt        ← buggy source (before_commit)
+├── post_functions.txt       ← patched source (after_commit)
+├── config.json              ← paths, commit_message, commit hashes, flags
+├── scan/
+│   ├── scan_before.sh       ← RUN ME: scan before_commit → N_buggy
+│   ├── scan_after.sh        ← RUN ME: scan after_commit → N_patched
+│   └── flags_*.txt          ← pre-extracted compile flags (-I, -D)
+├── references/
+│   ├── repo_knowledge.md            ← project-specific API/convention reference
+│   ├── patterns_summary.md       ← (optional) historical bug pattern summary
+│   ├── cwe_cards/                ← CWE knowledge library (all categories)
+│   │   ├── index.json             ← lookup index — use to find relevant cards
+│   │   ├── CWE-{id}(-variant).md  ← Tier 1/2 per-CWE detection patterns
+│   │   ├── Category-{name}.md     ← Tier 3 umbrella cards (rare CWEs grouped)
+│   ├── csa_headers_api.md   ← API quick reference (extracted from LLVM 18 headers)
+│   ├── csa_checker_patterns.md ← pattern catalog (resource tracking, null check, etc.)
+│   ├── csa_utility_functions.h ← copy-paste C++ helpers for checker.cpp (AST traversal, expression eval, etc.)
+│   └── examples/
+│       └── llvm-official/   ← 5 official checker sources (with comments)
+│           ├── 01_div_zero.cpp
+│           ├── 02_simple_stream.cpp
+│           ├── 03_undef_result.cpp
+│           ├── 04_nullability.cpp
+│           └── 05_malloc.cpp
+│
+├── checker.cpp              ← YOUR OUTPUT: synthesized checker
+├── checker.so               ← YOUR OUTPUT: compiled checker
+├── state.json               ← YOUR OUTPUT: structured task state
+├── scope_statement.md       ← YOUR OUTPUT: checker scope analysis (Level 1/2/3)
+└── summary.json             ← YOUR OUTPUT: final report
+```
+
+## Resources
+
+**Read these before writing any code:**
+
+1. **`references/csa_headers_api.md`** — CSA API quick reference. Extracted directly from
+   LLVM 18 headers. Covers all checker callbacks, ProgramState operations, SVal types,
+   MemRegion hierarchy, and bug reporting. **Read this first whenever you need API info.**
+
+2. **`references/csa_checker_patterns.md`** — Pattern catalog. Documents 5 battle-tested
+   patterns from official LLVM checkers: resource tracking, null checking, undefined
+   value detection, division-by-zero, and malloc/free. Each pattern includes skeleton
+   code, state traits, and key API usage.
+
+3. **`references/examples/llvm-official/`** — 5 official LLVM 18 checker implementations
+   with explanatory comments:
+   - `01_div_zero.cpp` — simplest checker (169 lines, 1 callback)
+   - `02_simple_stream.cpp` — resource tracking (292 lines, fopen/fclose)
+   - `03_undef_result.cpp` — PostStmt pattern (160 lines)
+   - `04_nullability.cpp` — multi-callback checker (1247 lines)
+   - `05_malloc.cpp` — comprehensive malloc/free (1511 lines)
+
+4. **`checker_template.cpp`** — Skeleton with placeholders. Start here.
+
+5. **`references/repo_knowledge.md`** — Project-specific reference. Contains this
+   repository's memory allocation API, key data types, source layout, and typical
+   CVE patterns. **Read this before writing the checker** — knowing the project's
+   alloc/free conventions and common bug patterns saves many grep rounds.
+
+5b. **`references/patterns_summary.md`** — (may not exist) Historical synthesis
+   patterns for this project.  If present, it contains a concise summary of the
+   most common bug patterns, frequent CWE categories, and reusable checker
+   architectures observed in previous synthesis runs.  Read after repo_knowledge.md.
+
+6. **`references/cwe_cards/`** — Complete CWE knowledge base covering all
+   vulnerability categories.  **The framework provides the full library —
+   you must identify the vulnerability type yourself.**  Workflow:
+
+   1. Analyse the patch diff and commit message to determine the vulnerability
+      type (buffer overflow, UAF, null deref, integer overflow, race condition,
+      etc.).  Do NOT rely on the CWE label — treat it as a hint at most.
+   2. Open ``index.json`` to discover available cards and their tiers.
+   3. Read the relevant card(s) for **detection strategies**, **checker
+      architecture suggestions**, and **known false-positive patterns**.
+
+   Card tiers:
+   - ``CWE-{id}(-{variant}).md`` — Tier 1/2 cards for common CWEs; kernel /
+     userspace variants when the detection strategy differs substantially.
+   - ``Category-{name}.md`` — Tier 3 umbrella cards grouping rarer CWEs by
+     category (input validation, resource management, etc.).
+
+7. **`references/csa_utility_functions.h`** — Copy-paste C++ helper functions for
+   checker.cpp. Includes AST traversal (`findSpecificTypeInParents/Children`),
+   expression evaluation (`EvaluateExprToInt`, `inferSymbolMaxVal`), array/string
+   size extraction, MemRegion helpers, and `ExprHasName()` for robust function
+   matching. All verified against LLVM 18. **Read before implementing detection
+   logic** — these save writing boilerplate that's easy to get wrong.
+
+## Environment
+
+Key paths are in ``config.json``.
+
+### Pre-built scripts
+
+| Script | What it does |
+|--------|-------------|
+| `bash compile.sh` | Compile checker.cpp → checker.so (with correct flags) |
+| `CHECKER_NAME=<name> bash scan/scan_before.sh` | Scan before_commit, count warnings → N_buggy |
+| `CHECKER_NAME=<name> bash scan/scan_after.sh` | Scan after_commit, count warnings → N_patched |
+
+```bash
+# Compile (run from workdir root)
+bash compile.sh
+
+# Scan — set CHECKER_NAME to the string passed to addChecker<>()
+CHECKER_NAME=your.CheckerName bash scan/scan_before.sh   # → N_buggy
+CHECKER_NAME=your.CheckerName bash scan/scan_after.sh    # → N_patched
+```
+
+- ``compile.sh`` already has the correct ``-I`` / ``-fno-rtti`` flags.
+- ``scan/scan_*.sh`` count only warnings tagged with your checker name.
+- Scan environments (source files + compile flags) are pre-built in ``scan/``.
+
+### Scan Script Integrity (CRITICAL)
+
+The scan scripts (``scan/scan_before.sh``, ``scan/scan_after.sh``) are the **only
+valid measurement** of N_buggy and N_patched.  They are the ground truth that the
+Python-side validator will also use.  You MUST obey these rules:
+
+**1. Never bypass the scan scripts.**  Do NOT run ``clang --analyze`` directly
+   to measure warning counts.  The Python validator runs the same scan scripts
+   — if you measured with a different command, your numbers will not reproduce
+   and the synthesis will be rejected.
+
+**2. If the scan script prints COMPILE_ERROR** (missing headers, undeclared
+   identifiers, etc.), the scan environment needs repair.  You MUST fix it:
+   - Add missing ``-I`` include paths to the flags files in ``scan/``
+   - Copy needed generated headers (e.g. ``autoconf.h``) from the snapshot
+   - If the file fundamentally cannot be compiled by clang, stop and write
+     ``summary.json`` with ``status: "failed"`` and an honest ``failure_reason``
+
+**3. Only trust scan script output.**  The ``Total <name> warnings: N`` line
+   printed by the scan script is the number that goes into ``summary.json``.
+   If the scan script says 0, write 0.  Fabricating numbers that the scan
+   script did not produce will cause the Python validator to reject the
+   synthesis.
+
+- If compile fails: read the error, fix ``checker.cpp``, retry (max 3 cycles).
+- If validation fails: revise checker logic, re-compile, re-scan.
+
+## MCP Tools
+
+You have access to 3 MCP tools under the `csa-tools` server (prefixed `mcp__csa-tools__`).
+Each returns **source context embedded in the result** — no need to follow up with Read.
+
+| Tool | What it does | Key advantage |
+|------|-------------|---------------|
+| `search(pattern, scope)` | Search for a pattern in source / LLVM headers / workdir | Returns file:line + 3 lines context — grep + Read in one call |
+| `compile()` | Run compile.sh, return parsed diagnostics | Errors include checker.cpp context — fix without reading the file |
+| `scan(checker_name)` | Run before/after scan, return N_buggy + N_patched + warning locations | Each warning includes source context — no manual clang --analyze needed |
+
+### When to use each
+
+- **`search`**: Whenever you would type `grep -rn "X"` or `find ... -name`. Use `scope="source"` for CVE code, `scope="llvm"` for CSA API headers, `scope="all"` when unsure.
+- **`compile`**: Instead of `bash compile.sh` followed by reading checker.cpp at error lines.
+- **`scan`**: Instead of running scan_before.sh + scan_after.sh + manual clang inspection. Returns everything you need to decide next action.
+
+## Semantic Design Contract — before writing checker.cpp
+
+Create the analysis portions of `state.json` and `scope_statement.md` **before**
+writing checker.cpp. They are a design contract, not a retrospective summary.
+After compilation, update only implementation facts such as `build_attempts`.
+
+In `patch_analysis`, distinguish the vulnerable operation, its trigger, and the
+semantic fact introduced by the patch that makes it safe. In `detection_plan`,
+make `report_condition`, `safe_condition`, and `source_level_signal` concrete
+CSA-observable facts. In `api_choice`, record the mechanism level and explain
+why the selected callback can observe and prove those facts.
+
+In `scope_statement.md`, include this mapping table and check it again after
+implementation:
+
+| Semantic condition | CSA evidence | checker.cpp implementation |
+| --- | --- | --- |
+| report condition | AST / SVal / MemRegion / CFG evidence | callback, helper, and branch that reports |
+| safe condition | path constraint, guard, state discharge, or structural fact | branch that suppresses the report |
+
+Every condition in the plan must have an implementation entry. Do not claim a
+condition that checker.cpp does not implement, and do not silently add a code
+condition absent from the plan.
+
+## Mechanism Selection — diagnose before coding
+
+Choose the weakest CSA mechanism that can prove the vulnerability property:
+
+1. **syntax-only AST**: only when local AST shape itself is the defect;
+2. **control flow / dominance**: when guard placement relative to a sink matters;
+3. **path-sensitive ProgramState/SVal**: when an unsafe state must reach a use;
+4. **cross-procedure/dataflow**: when the required fact crosses function boundaries.
+
+For a guard-based patch, prove both that the guard rejects the unsafe value and
+that it dominates the vulnerable use. For path-sensitive or cross-procedure
+defects, do not replace the required state or flow proof with local AST matching
+or source-text substring matching merely because it passes the differential scan.
+Record the selected level as `api_choice.mechanism_level`.
+
+## Semantic identity, locality, and final validation
+
+Before accepting the checker, verify that its primary matching logic does not
+depend on patch-local variable names, labels, line numbers, commit IDs, or unique
+literals. Project APIs, types, and stable semantic call relationships are valid
+scope anchors when they define the vulnerability class. Attach the report to the
+actual vulnerable operation, and implement every suppression as a real safe
+condition rather than the mere presence of a nearby guard-shaped statement.
+
+The required final sequence is: **compile → before scan → after scan → inspect
+the final checker name, artifacts, and report locations → write summary.json**.
+Always run the final compile and both scans. `MAX_IN_SESSION_REDESIGNS` limits only
+additional redesign cycles after a failed validation; if it is zero, preserve the
+real validation evidence and report failure honestly rather than fabricating counts.
+
+## Validation Criteria
+
+```
+VALID   : N_buggy > N_patched  AND  N_patched < 50
+INVALID : otherwise → revise and re-validate (max 1 attempts)
+```
+
+## Refinement
+
+Do NOT self-refine the checker repeatedly. Your goal is to produce the first
+checker that passes the Validation Criteria above — fix compile errors and
+validation failures only. False positives are triaged and repaired by the
+framework's refinement stage: you will receive a concrete FP list via
+session resume (if needed) and fix only those. Reserve budget for that stage.
+
+## Output
+
+Produce all of the following **only when completely done**:
+
+| File | Content |
+|------|---------|
+| ``checker.cpp`` | Synthesized checker source code |
+| ``checker.so`` | Compiled checker plugin |
+| ``state.json`` | Structured task state (see schema below) |
+| ``scope_statement.md`` | Checker scope analysis in prose (Level 1/2/3) |
+| ``summary.json`` | Final report (see schema below) |
+
+Writing ``summary.json`` signals completion.  Do NOT write it early.
+
+### ``state.json``
+
+Create this before writing checker.cpp to capture the design contract. After the
+checker compiles, update only implementation facts and retain the original
+semantic plan.
+
+```json
+{
+  "patch_analysis": {
+    "summary":           "One sentence describing the vulnerability this patch fixes",
+    "changed_files":     ["file1.c", "file2.h"],
+    "changed_functions": ["func_a", "func_b"],
+    "bug_type":          "buffer_overflow | use_after_free | null_deref | integer_overflow | race_condition | resource_leak | double_free | input_validation | other",
+    "fix_strategy":      "add_bounds_check | add_null_check | add_size_check | add_early_return | reorder_operations | change_api_signature | other",
+    "affected_types":    ["GF_BitStream", "custom_struct_t"],
+    "critical_calls":    ["gf_strdup", "memcpy"]
+  },
+  "detection_plan": {
+    "bug_pattern":         "High-level description of the vulnerability pattern (e.g. 'heap buffer overflow when reading variable-length data into a fixed-size stack buffer without size bound')",
+    "report_condition":    "When should the checker emit a warning? (e.g. 'call to gf_strdup where the argument originates from a fixed-size local array that was populated by variable-length bitstream reads')",
+    "safe_condition":      "When should the checker NOT emit a warning? (e.g. 'argument originates from a heap allocation or a size-bounded source')",
+    "source_level_signal": "What AST / MemRegion / SVal property does the checker look for? (e.g. 'MemRegion extent < parameter size at a PreCall to gf_strdup')"
+  },
+  "api_choice": {
+    "mechanism_level":          "syntactic_ast | control_flow | path_sensitive | interprocedural_dataflow",
+    "callback":                 "check::PreCall | check::PostCall | check::PreStmt | check::PostStmt | check::Bind | check::DeadSymbols | check::EndFunction | ...",
+    "reasoning":                "Why this callback and its AST/state/CFG evidence prove the report and safe conditions",
+    "alternatives_considered":  ["check::PostCall"]
+  },
+  "implementation": {
+    "scope_level":    "patch_specific | project_general | cross_project",
+    "checker_name":   "project.CheckerName",
+    "build_attempts": 1
+  }
+}
+```
+
+### ``summary.json``
+
+```json
+{
+  "status":           "plausible | failed",
+  "bug_pattern":      "One sentence describing the bug pattern",
+  "scope_level":      "patch_specific | project_general | cross_project",
+  "checker_cpp":      "checker.cpp",
+  "checker_so":       "checker.so",
+  "n_buggy":          0,
+  "n_patched":        0,
+  "total_reports":    0,
+  "fp_rate_estimate": 0.0,
+  "failure_reason":   null
+}
+```
+
+## Feedback-derived requirements for this fresh synthesis
+
+A prior independent rollout exposed the risks below. Start again from the patch
+in this new session. Do not reconstruct, edit, or assume the prior checker.
+
+Required mechanism level: `syntax_only`
+
+### Current failure diagnosis
+
+- semantic_mechanism failed because path-sensitive RCULockDepth ProgramState tracking plus a static-versus-exported entry heuristic were judged overkill; the required relation is a same-function AST fact.
+- refinement_accepted failed with outcome feedback_required after one round; the rollout never converged on an accepted mechanism.
+- The prior design proved exploded-graph lock-state reachability even though absence of rcu_read_lock in the same non-static function as list_for_each_entry_rcu is visible from an AST walk.
+
+### Preserve from prior rollouts
+
+- Preserve successful compile, before/after validation, and code verification.
+- Preserve objective eligibility gate G6.
+- Preserve semantic score at or above the configured threshold.
+- Preserve process quality at or above the configured threshold.
+- Do not introduce patch-anchor dependence.
+- Do not introduce patch-local hardcoding.
+
+### Required semantic proof
+
+- Report when a non-static function body expands an RCU list-traversal macro (list_for_each_entry_rcu and documented friends) and does not itself contain an rcu_read_lock family call; that is the pre-patch rpc_xprt_switch_has_addr defect.
+- Treat as safe when the traversal lives only in a static helper, or when the same function contains rcu_read_lock/rcu_read_lock_bh/rcu_read_lock_sched/rcu_read_lock_nested (post-patch: lock in the public wrapper, walk in static __rpc_xprt_switch_has_addr).
+- Exported functions may be invoked without a held RCU read-side critical section; file-local helpers may rely on their callers and must not be treated as standalone defects.
+
+### Implementation constraints
+
+- Use an AST-body or AST-declaration callback over function definitions; do not register ProgramState traits or update lock nesting on exploded-graph paths.
+- Detect RCU traversals by macro-expansion names (list_for_each_entry_rcu, list_for_each_entry_continue_rcu, list_for_each_entry_from_rcu, list_for_each_rcu, hlist_for_each_entry_rcu and documented friends) and lock acquisition by callee identifiers in the rcu_read_lock family.
+- Emit the diagnostic at the traversal site inside non-static FunctionDecls only; suppress SC_Static helpers.
+- Remain project_general for the Linux RCU list protocol; do not key checks off net/sunrpc/xprtmultipath.c, rpc_xprt_switch_has_addr, __rpc_xprt_switch_has_addr, or patch line numbers.
+- If walking statements, use the loop-condition or macro-expansion location; these RCU macros need not appear as a ForStmt CFG node.
+
+### Validation checklist
+
+- Plugin compiles, registers, and keeps hard_validation passing.
+- before_commit scan of net/sunrpc/xprtmultipath.c reports on non-static rpc_xprt_switch_has_addr at list_for_each_entry_rcu with N_buggy > 0.
+- after_commit scan yields N_patched = 0 because the public wrapper contains rcu_read_lock without a traversal and the static helper is suppressed.
+- No warning on pre-existing static helpers such as xprt_switch_find_next_entry that also expand list_for_each_entry_rcu.
+- Reports stay in the patched function near the traversal; no unrelated disappeared diagnostics.
+- Refinement must be accepted; semantic_mechanism must classify the checker as syntax_only rather than path-sensitive overkill.
+
+### Avoid and forbidden regressions
+
+- Do not reintroduce RCULockDepth, checkBeginFunction entry-depth seeding, checkPreCall lock/unlock counting, or checkBranchCondition sink reporting.
+- Do not treat inlining or exploded-graph lock reachability as required for this instance.
+- Do not emit reports on static RCU helpers whose callers are expected to hold rcu_read_lock.
+- Do not drop compile, before/after, G6, anchor_free, or hardcoding_free invariants to chase mechanism score.

tasks/csa159/pair_165542/checker_template.cpp

@@ -0,0 +1,98 @@
+// ============================================================================
+// CSA Checker Template
+// ============================================================================
+// Fill in the sections marked with TODO to implement your checker.
+// The checker is compiled with -fno-rtti to match the LLVM 18 build config.
+// It is loaded via: clang -cc1 -load checker.so -analyzer-checker=your.CheckerName
+//
+// Compilation:
+//   clang++ -std=c++17 -fPIC -shared -fno-rtti -fno-exceptions \
+//           -I${LLVM_BUILD_DIR}/include \
+//           checker.cpp -o checker.so \
+//           -Wl,--allow-shlib-undefined
+//
+// Usage:
+//   clang -cc1 -load ./checker.so -analyzer-checker=your.CheckerName -analyze <file>
+// ============================================================================
+
+#include "clang/StaticAnalyzer/Core/BugReporter/BugReporter.h"
+#include "clang/StaticAnalyzer/Core/BugReporter/BugType.h"
+#include "clang/StaticAnalyzer/Core/Checker.h"
+#include "clang/StaticAnalyzer/Core/PathSensitive/CallEvent.h"
+#include "clang/StaticAnalyzer/Core/PathSensitive/CheckerContext.h"
+#include "clang/StaticAnalyzer/Frontend/CheckerRegistry.h"
+
+using namespace clang;
+using namespace ento;
+
+namespace {
+
+// ────────────────────────────────────────────────────────────────
+// TODO: Rename this class to describe your checker's purpose.
+// ────────────────────────────────────────────────────────────────
+class {{CHECKER_CLASS_NAME}}
+    : public Checker<check::PreCall,      // for checking before function calls
+                     check::PostCall>     // for checking after function calls
+{
+  // TODO: Customize the bug type name and category.
+  mutable std::unique_ptr<BugType> BT;
+
+public:
+  {{CHECKER_CLASS_NAME}}()
+      : BT(new BugType(this, "{{BUG_NAME}}", "{{BUG_CATEGORY}}")) {}
+
+  // ── PreCall callback (fires before every function call) ──────
+  void checkPreCall(const CallEvent &Call, CheckerContext &C) const {
+    // TODO: Implement your pre-call analysis logic here.
+    //
+    // Common patterns:
+    //
+    // 1. Check if the called function matches a specific name:
+    //    if (Call.getCalleeIdentifier()) {
+    //      StringRef name = Call.getCalleeIdentifier()->getName();
+    //      if (name == "target_function") { ... }
+    //    }
+    //
+    // 2. Get the program state:
+    //    ProgramStateRef State = C.getState();
+    //
+    // 3. Get arguments:
+    //    SVal Arg = Call.getArgSVal(0);
+    //
+    // 4. Generate a bug report:
+    //    ExplodedNode *ErrNode = C.generateErrorNode();
+    //    if (ErrNode) {
+    //      auto R = std::make_unique<PathSensitiveBugReport>(
+    //          *BT, "Description of the bug", ErrNode);
+    //      C.emitReport(std::move(R));
+    //    }
+  }
+
+  // ── PostCall callback (fires after every function call) ─────
+  void checkPostCall(const CallEvent &Call, CheckerContext &C) const {
+    // TODO: Implement your post-call analysis logic here.
+    //
+    // Common pattern — check the return value:
+    //   SVal RetVal = Call.getReturnValue();
+    //   if (RetVal.isUnknownOrUndef()) return;
+    //
+    //   ProgramStateRef State = C.getState();
+    //   // Modify state based on post-call conditions...
+  }
+};
+
+} // anonymous namespace
+
+// ────────────────────────────────────────────────────────────────
+// Registration — DO NOT modify the function signatures.
+// ────────────────────────────────────────────────────────────────
+
+extern "C" void clang_registerCheckers(CheckerRegistry &registry) {
+  registry.addChecker<{{CHECKER_CLASS_NAME}}>(
+      "{{CHECKER_FULL_NAME}}",  // e.g., "your.NullDereferenceChecker"
+      "{{CHECKER_DESC}}",       // e.g., "Detects null pointer dereference"
+      "{{CHECKER_DOC_URI}}");   // e.g., "https://example.com/docs"
+}
+
+extern "C" const char clang_analyzerAPIVersionString[] =
+    CLANG_ANALYZER_API_VERSION_STRING;

tasks/csa159/pair_165542/config.json

@@ -0,0 +1,19 @@
+{
+  "project_id": "torvalds_linux",
+  "before_commit": "e3952fcce1aad934f1322843b564ff86256444b2",
+  "after_commit": "cc16eecae687912238ee6efbff71ad31e2bc414e",
+  "repo_path": "/workspace/repo/torvalds/linux",
+  "llvm_build_dir": "/opt/llvm",
+  "before_compile_commands": "/workspace/benchmark/data-pipeline/snapshots/torvalds_linux/cfb92440ee71adcc2105b0890bb01ac3cddb8507/compile_commands.json",
+  "after_compile_commands": "/workspace/benchmark/data-pipeline/snapshots/torvalds_linux/cfb92440ee71adcc2105b0890bb01ac3cddb8507/compile_commands.json",
+  "changed_files": [
+    "fs/jbd2/transaction.c"
+  ],
+  "commit_message": "jbd2: fix use-after-free of transaction_t race\n\njbd2_journal_wait_updates() is called with j_state_lock held. But if\nthere is a commit in progress, then this transaction might get committed\nand freed via jbd2_journal_commit_transaction() ->\njbd2_journal_free_transaction(), when we release j_state_lock.\nSo check for journal->j_running_transaction everytime we release and\nacquire j_state_lock to avoid use-after-free issue.\n\nLink: https://lore.kernel.org/r/948c2fed518ae739db6a8f7f83f1d58b504f87d0.1644497105.git.ritesh.list@gmail.com\nFixes: 4f98186848707f53 (\"jbd2: refactor wait logic for transaction updates into a common function\")\nCc: stable@kernel.org\nReported-and-tested-by: syzbot+afa2ca5171d93e44b348@syzkaller.appspotmail.com\nReviewed-by: Jan Kara <jack@suse.cz>\nSigned-off-by: Ritesh Harjani <riteshh@linux.ibm.com>\nSigned-off-by: Theodore Ts'o <tytso@mit.edu>",
+  "t_valid": 50,
+  "t_plausible": 20,
+  "triage_sample_size": 10,
+  "max_synthesis_retry": 0,
+  "max_in_session_redesigns": 1,
+  "max_refinement_iter": 3
+}

tasks/csa159/pair_165542/patch.diff

@@ -0,0 +1,66 @@
+diff --git a/fs/jbd2/transaction.c b/fs/jbd2/transaction.c
+index 8e2f8275a253..259e00046a8b 100644
+--- a/fs/jbd2/transaction.c
++++ b/fs/jbd2/transaction.c
+@@ -842,27 +842,38 @@ EXPORT_SYMBOL(jbd2_journal_restart);
+  */
+ void jbd2_journal_wait_updates(journal_t *journal)
+ {
+-	transaction_t *commit_transaction = journal->j_running_transaction;
++	DEFINE_WAIT(wait);
+ 
+-	if (!commit_transaction)
+-		return;
++	while (1) {
++		/*
++		 * Note that the running transaction can get freed under us if
++		 * this transaction is getting committed in
++		 * jbd2_journal_commit_transaction() ->
++		 * jbd2_journal_free_transaction(). This can only happen when we
++		 * release j_state_lock -> schedule() -> acquire j_state_lock.
++		 * Hence we should everytime retrieve new j_running_transaction
++		 * value (after j_state_lock release acquire cycle), else it may
++		 * lead to use-after-free of old freed transaction.
++		 */
++		transaction_t *transaction = journal->j_running_transaction;
+ 
+-	spin_lock(&commit_transaction->t_handle_lock);
+-	while (atomic_read(&commit_transaction->t_updates)) {
+-		DEFINE_WAIT(wait);
++		if (!transaction)
++			break;
+ 
++		spin_lock(&transaction->t_handle_lock);
+ 		prepare_to_wait(&journal->j_wait_updates, &wait,
+-					TASK_UNINTERRUPTIBLE);
+-		if (atomic_read(&commit_transaction->t_updates)) {
+-			spin_unlock(&commit_transaction->t_handle_lock);
+-			write_unlock(&journal->j_state_lock);
+-			schedule();
+-			write_lock(&journal->j_state_lock);
+-			spin_lock(&commit_transaction->t_handle_lock);
++				TASK_UNINTERRUPTIBLE);
++		if (!atomic_read(&transaction->t_updates)) {
++			spin_unlock(&transaction->t_handle_lock);
++			finish_wait(&journal->j_wait_updates, &wait);
++			break;
+ 		}
++		spin_unlock(&transaction->t_handle_lock);
++		write_unlock(&journal->j_state_lock);
++		schedule();
+ 		finish_wait(&journal->j_wait_updates, &wait);
++		write_lock(&journal->j_state_lock);
+ 	}
+-	spin_unlock(&commit_transaction->t_handle_lock);
+ }
+ 
+ /**
+@@ -877,8 +888,6 @@ void jbd2_journal_wait_updates(journal_t *journal)
+  */
+ void jbd2_journal_lock_updates(journal_t *journal)
+ {
+-	DEFINE_WAIT(wait);
+-
+ 	jbd2_might_wait_for_commit(journal);
+ 
+ 	write_lock(&journal->j_state_lock);

tasks/csa159/pair_165542/post_functions.txt

@@ -0,0 +1,38 @@
+### File: fs/jbd2/transaction.c
+```c
+void jbd2_journal_wait_updates(journal_t *journal)
+{
+	DEFINE_WAIT(wait);
+
+	while (1) {
+		/*
+		 * Note that the running transaction can get freed under us if
+		 * this transaction is getting committed in
+		 * jbd2_journal_commit_transaction() ->
+		 * jbd2_journal_free_transaction(). This can only happen when we
+		 * release j_state_lock -> schedule() -> acquire j_state_lock.
+		 * Hence we should everytime retrieve new j_running_transaction
+		 * value (after j_state_lock release acquire cycle), else it may
+		 * lead to use-after-free of old freed transaction.
+		 */
+		transaction_t *transaction = journal->j_running_transaction;
+
+		if (!transaction)
+			break;
+
+		spin_lock(&transaction->t_handle_lock);
+		prepare_to_wait(&journal->j_wait_updates, &wait,
+				TASK_UNINTERRUPTIBLE);
+		if (!atomic_read(&transaction->t_updates)) {
+			spin_unlock(&transaction->t_handle_lock);
+			finish_wait(&journal->j_wait_updates, &wait);
+			break;
+		}
+		spin_unlock(&transaction->t_handle_lock);
+		write_unlock(&journal->j_state_lock);
+		schedule();
+		finish_wait(&journal->j_wait_updates, &wait);
+		write_lock(&journal->j_state_lock);
+	}
+}
+```

tasks/csa159/pair_165542/pre_functions.txt

@@ -0,0 +1,58 @@
+### File: fs/jbd2/transaction.c
+```c
+void jbd2_journal_wait_updates(journal_t *journal)
+{
+	transaction_t *commit_transaction = journal->j_running_transaction;
+
+	if (!commit_transaction)
+		return;
+
+	spin_lock(&commit_transaction->t_handle_lock);
+	while (atomic_read(&commit_transaction->t_updates)) {
+		DEFINE_WAIT(wait);
+
+		prepare_to_wait(&journal->j_wait_updates, &wait,
+					TASK_UNINTERRUPTIBLE);
+		if (atomic_read(&commit_transaction->t_updates)) {
+			spin_unlock(&commit_transaction->t_handle_lock);
+			write_unlock(&journal->j_state_lock);
+			schedule();
+			write_lock(&journal->j_state_lock);
+			spin_lock(&commit_transaction->t_handle_lock);
+		}
+		finish_wait(&journal->j_wait_updates, &wait);
+	}
+	spin_unlock(&commit_transaction->t_handle_lock);
+}
+
+void jbd2_journal_lock_updates(journal_t *journal)
+{
+	DEFINE_WAIT(wait);
+
+	jbd2_might_wait_for_commit(journal);
+
+	write_lock(&journal->j_state_lock);
+	++journal->j_barrier_count;
+
+	/* Wait until there are no reserved handles */
+	if (atomic_read(&journal->j_reserved_credits)) {
+		write_unlock(&journal->j_state_lock);
+		wait_event(journal->j_wait_reserved,
+			   atomic_read(&journal->j_reserved_credits) == 0);
+		write_lock(&journal->j_state_lock);
+	}
+
+	/* Wait until there are no running t_updates */
+	jbd2_journal_wait_updates(journal);
+
+	write_unlock(&journal->j_state_lock);
+
+	/*
+	 * We have now established a barrier against other normal updates, but
+	 * we also need to barrier against other jbd2_journal_lock_updates() calls
+	 * to make sure that we serialise special journal-locked operations
+	 * too.
+	 */
+	mutex_lock(&journal->j_barrier);
+}
+```

tasks/csa159/pair_165542/task_prompt.md

@@ -0,0 +1,382 @@
+# Task: Synthesize a CSA Checker from a CVE Patch
+
+## Your Role
+
+You are a static analysis expert. Synthesize a Clang Static Analyzer (CSA) checker
+that detects the bug pattern fixed by the CVE patch in this working directory.
+
+You have full filesystem and bash access — use them.
+
+### Skills
+
+Many skills are available under `.claude/skills/` — covering vulnerability analysis,
+checker design, debugging, code audit, security patterns, and more.  Each skill
+encodes reusable expertise: take time to explore them, read their SKILL.md files,
+and invoke those that look useful via the Skill tool.  Let the task guide which
+ones you reach for.
+
+## File Layout
+
+```
+/work/
+├── compile.sh               ← RUN ME: compile checker.cpp → checker.so
+├── checker_template.cpp     ← skeleton, start here
+├── patch.diff               ← the CVE fix
+├── pre_functions.txt        ← buggy source (before_commit)
+├── post_functions.txt       ← patched source (after_commit)
+├── config.json              ← paths, commit_message, commit hashes, flags
+├── scan/
+│   ├── scan_before.sh       ← RUN ME: scan before_commit → N_buggy
+│   ├── scan_after.sh        ← RUN ME: scan after_commit → N_patched
+│   └── flags_*.txt          ← pre-extracted compile flags (-I, -D)
+├── references/
+│   ├── repo_knowledge.md            ← project-specific API/convention reference
+│   ├── patterns_summary.md       ← (optional) historical bug pattern summary
+│   ├── cwe_cards/                ← CWE knowledge library (all categories)
+│   │   ├── index.json             ← lookup index — use to find relevant cards
+│   │   ├── CWE-{id}(-variant).md  ← Tier 1/2 per-CWE detection patterns
+│   │   ├── Category-{name}.md     ← Tier 3 umbrella cards (rare CWEs grouped)
+│   ├── csa_headers_api.md   ← API quick reference (extracted from LLVM 18 headers)
+│   ├── csa_checker_patterns.md ← pattern catalog (resource tracking, null check, etc.)
+│   ├── csa_utility_functions.h ← copy-paste C++ helpers for checker.cpp (AST traversal, expression eval, etc.)
+│   └── examples/
+│       └── llvm-official/   ← 5 official checker sources (with comments)
+│           ├── 01_div_zero.cpp
+│           ├── 02_simple_stream.cpp
+│           ├── 03_undef_result.cpp
+│           ├── 04_nullability.cpp
+│           └── 05_malloc.cpp
+│
+├── checker.cpp              ← YOUR OUTPUT: synthesized checker
+├── checker.so               ← YOUR OUTPUT: compiled checker
+├── state.json               ← YOUR OUTPUT: structured task state
+├── scope_statement.md       ← YOUR OUTPUT: checker scope analysis (Level 1/2/3)
+└── summary.json             ← YOUR OUTPUT: final report
+```
+
+## Resources
+
+**Read these before writing any code:**
+
+1. **`references/csa_headers_api.md`** — CSA API quick reference. Extracted directly from
+   LLVM 18 headers. Covers all checker callbacks, ProgramState operations, SVal types,
+   MemRegion hierarchy, and bug reporting. **Read this first whenever you need API info.**
+
+2. **`references/csa_checker_patterns.md`** — Pattern catalog. Documents 5 battle-tested
+   patterns from official LLVM checkers: resource tracking, null checking, undefined
+   value detection, division-by-zero, and malloc/free. Each pattern includes skeleton
+   code, state traits, and key API usage.
+
+3. **`references/examples/llvm-official/`** — 5 official LLVM 18 checker implementations
+   with explanatory comments:
+   - `01_div_zero.cpp` — simplest checker (169 lines, 1 callback)
+   - `02_simple_stream.cpp` — resource tracking (292 lines, fopen/fclose)
+   - `03_undef_result.cpp` — PostStmt pattern (160 lines)
+   - `04_nullability.cpp` — multi-callback checker (1247 lines)
+   - `05_malloc.cpp` — comprehensive malloc/free (1511 lines)
+
+4. **`checker_template.cpp`** — Skeleton with placeholders. Start here.
+
+5. **`references/repo_knowledge.md`** — Project-specific reference. Contains this
+   repository's memory allocation API, key data types, source layout, and typical
+   CVE patterns. **Read this before writing the checker** — knowing the project's
+   alloc/free conventions and common bug patterns saves many grep rounds.
+
+5b. **`references/patterns_summary.md`** — (may not exist) Historical synthesis
+   patterns for this project.  If present, it contains a concise summary of the
+   most common bug patterns, frequent CWE categories, and reusable checker
+   architectures observed in previous synthesis runs.  Read after repo_knowledge.md.
+
+6. **`references/cwe_cards/`** — Complete CWE knowledge base covering all
+   vulnerability categories.  **The framework provides the full library —
+   you must identify the vulnerability type yourself.**  Workflow:
+
+   1. Analyse the patch diff and commit message to determine the vulnerability
+      type (buffer overflow, UAF, null deref, integer overflow, race condition,
+      etc.).  Do NOT rely on the CWE label — treat it as a hint at most.
+   2. Open ``index.json`` to discover available cards and their tiers.
+   3. Read the relevant card(s) for **detection strategies**, **checker
+      architecture suggestions**, and **known false-positive patterns**.
+
+   Card tiers:
+   - ``CWE-{id}(-{variant}).md`` — Tier 1/2 cards for common CWEs; kernel /
+     userspace variants when the detection strategy differs substantially.
+   - ``Category-{name}.md`` — Tier 3 umbrella cards grouping rarer CWEs by
+     category (input validation, resource management, etc.).
+
+7. **`references/csa_utility_functions.h`** — Copy-paste C++ helper functions for
+   checker.cpp. Includes AST traversal (`findSpecificTypeInParents/Children`),
+   expression evaluation (`EvaluateExprToInt`, `inferSymbolMaxVal`), array/string
+   size extraction, MemRegion helpers, and `ExprHasName()` for robust function
+   matching. All verified against LLVM 18. **Read before implementing detection
+   logic** — these save writing boilerplate that's easy to get wrong.
+
+## Environment
+
+Key paths are in ``config.json``.
+
+### Pre-built scripts
+
+| Script | What it does |
+|--------|-------------|
+| `bash compile.sh` | Compile checker.cpp → checker.so (with correct flags) |
+| `CHECKER_NAME=<name> bash scan/scan_before.sh` | Scan before_commit, count warnings → N_buggy |
+| `CHECKER_NAME=<name> bash scan/scan_after.sh` | Scan after_commit, count warnings → N_patched |
+
+```bash
+# Compile (run from workdir root)
+bash compile.sh
+
+# Scan — set CHECKER_NAME to the string passed to addChecker<>()
+CHECKER_NAME=your.CheckerName bash scan/scan_before.sh   # → N_buggy
+CHECKER_NAME=your.CheckerName bash scan/scan_after.sh    # → N_patched
+```
+
+- ``compile.sh`` already has the correct ``-I`` / ``-fno-rtti`` flags.
+- ``scan/scan_*.sh`` count only warnings tagged with your checker name.
+- Scan environments (source files + compile flags) are pre-built in ``scan/``.
+
+### Scan Script Integrity (CRITICAL)
+
+The scan scripts (``scan/scan_before.sh``, ``scan/scan_after.sh``) are the **only
+valid measurement** of N_buggy and N_patched.  They are the ground truth that the
+Python-side validator will also use.  You MUST obey these rules:
+
+**1. Never bypass the scan scripts.**  Do NOT run ``clang --analyze`` directly
+   to measure warning counts.  The Python validator runs the same scan scripts
+   — if you measured with a different command, your numbers will not reproduce
+   and the synthesis will be rejected.
+
+**2. If the scan script prints COMPILE_ERROR** (missing headers, undeclared
+   identifiers, etc.), the scan environment needs repair.  You MUST fix it:
+   - Add missing ``-I`` include paths to the flags files in ``scan/``
+   - Copy needed generated headers (e.g. ``autoconf.h``) from the snapshot
+   - If the file fundamentally cannot be compiled by clang, stop and write
+     ``summary.json`` with ``status: "failed"`` and an honest ``failure_reason``
+
+**3. Only trust scan script output.**  The ``Total <name> warnings: N`` line
+   printed by the scan script is the number that goes into ``summary.json``.
+   If the scan script says 0, write 0.  Fabricating numbers that the scan
+   script did not produce will cause the Python validator to reject the
+   synthesis.
+
+- If compile fails: read the error, fix ``checker.cpp``, retry (max 3 cycles).
+- If validation fails: revise checker logic, re-compile, re-scan.
+
+## MCP Tools
+
+You have access to 3 MCP tools under the `csa-tools` server (prefixed `mcp__csa-tools__`).
+Each returns **source context embedded in the result** — no need to follow up with Read.
+
+| Tool | What it does | Key advantage |
+|------|-------------|---------------|
+| `search(pattern, scope)` | Search for a pattern in source / LLVM headers / workdir | Returns file:line + 3 lines context — grep + Read in one call |
+| `compile()` | Run compile.sh, return parsed diagnostics | Errors include checker.cpp context — fix without reading the file |
+| `scan(checker_name)` | Run before/after scan, return N_buggy + N_patched + warning locations | Each warning includes source context — no manual clang --analyze needed |
+
+### When to use each
+
+- **`search`**: Whenever you would type `grep -rn "X"` or `find ... -name`. Use `scope="source"` for CVE code, `scope="llvm"` for CSA API headers, `scope="all"` when unsure.
+- **`compile`**: Instead of `bash compile.sh` followed by reading checker.cpp at error lines.
+- **`scan`**: Instead of running scan_before.sh + scan_after.sh + manual clang inspection. Returns everything you need to decide next action.
+
+## Semantic Design Contract — before writing checker.cpp
+
+Create the analysis portions of `state.json` and `scope_statement.md` **before**
+writing checker.cpp. They are a design contract, not a retrospective summary.
+After compilation, update only implementation facts such as `build_attempts`.
+
+In `patch_analysis`, distinguish the vulnerable operation, its trigger, and the
+semantic fact introduced by the patch that makes it safe. In `detection_plan`,
+make `report_condition`, `safe_condition`, and `source_level_signal` concrete
+CSA-observable facts. In `api_choice`, record the mechanism level and explain
+why the selected callback can observe and prove those facts.
+
+In `scope_statement.md`, include this mapping table and check it again after
+implementation:
+
+| Semantic condition | CSA evidence | checker.cpp implementation |
+| --- | --- | --- |
+| report condition | AST / SVal / MemRegion / CFG evidence | callback, helper, and branch that reports |
+| safe condition | path constraint, guard, state discharge, or structural fact | branch that suppresses the report |
+
+Every condition in the plan must have an implementation entry. Do not claim a
+condition that checker.cpp does not implement, and do not silently add a code
+condition absent from the plan.
+
+## Mechanism Selection — diagnose before coding
+
+Choose the weakest CSA mechanism that can prove the vulnerability property:
+
+1. **syntax-only AST**: only when local AST shape itself is the defect;
+2. **control flow / dominance**: when guard placement relative to a sink matters;
+3. **path-sensitive ProgramState/SVal**: when an unsafe state must reach a use;
+4. **cross-procedure/dataflow**: when the required fact crosses function boundaries.
+
+For a guard-based patch, prove both that the guard rejects the unsafe value and
+that it dominates the vulnerable use. For path-sensitive or cross-procedure
+defects, do not replace the required state or flow proof with local AST matching
+or source-text substring matching merely because it passes the differential scan.
+Record the selected level as `api_choice.mechanism_level`.
+
+## Semantic identity, locality, and final validation
+
+Before accepting the checker, verify that its primary matching logic does not
+depend on patch-local variable names, labels, line numbers, commit IDs, or unique
+literals. Project APIs, types, and stable semantic call relationships are valid
+scope anchors when they define the vulnerability class. Attach the report to the
+actual vulnerable operation, and implement every suppression as a real safe
+condition rather than the mere presence of a nearby guard-shaped statement.
+
+The required final sequence is: **compile → before scan → after scan → inspect
+the final checker name, artifacts, and report locations → write summary.json**.
+Always run the final compile and both scans. `MAX_IN_SESSION_REDESIGNS` limits only
+additional redesign cycles after a failed validation; if it is zero, preserve the
+real validation evidence and report failure honestly rather than fabricating counts.
+
+## Validation Criteria
+
+```
+VALID   : N_buggy > N_patched  AND  N_patched < 50
+INVALID : otherwise → revise and re-validate (max 1 attempts)
+```
+
+## Refinement
+
+Do NOT self-refine the checker repeatedly. Your goal is to produce the first
+checker that passes the Validation Criteria above — fix compile errors and
+validation failures only. False positives are triaged and repaired by the
+framework's refinement stage: you will receive a concrete FP list via
+session resume (if needed) and fix only those. Reserve budget for that stage.
+
+## Output
+
+Produce all of the following **only when completely done**:
+
+| File | Content |
+|------|---------|
+| ``checker.cpp`` | Synthesized checker source code |
+| ``checker.so`` | Compiled checker plugin |
+| ``state.json`` | Structured task state (see schema below) |
+| ``scope_statement.md`` | Checker scope analysis in prose (Level 1/2/3) |
+| ``summary.json`` | Final report (see schema below) |
+
+Writing ``summary.json`` signals completion.  Do NOT write it early.
+
+### ``state.json``
+
+Create this before writing checker.cpp to capture the design contract. After the
+checker compiles, update only implementation facts and retain the original
+semantic plan.
+
+```json
+{
+  "patch_analysis": {
+    "summary":           "One sentence describing the vulnerability this patch fixes",
+    "changed_files":     ["file1.c", "file2.h"],
+    "changed_functions": ["func_a", "func_b"],
+    "bug_type":          "buffer_overflow | use_after_free | null_deref | integer_overflow | race_condition | resource_leak | double_free | input_validation | other",
+    "fix_strategy":      "add_bounds_check | add_null_check | add_size_check | add_early_return | reorder_operations | change_api_signature | other",
+    "affected_types":    ["GF_BitStream", "custom_struct_t"],
+    "critical_calls":    ["gf_strdup", "memcpy"]
+  },
+  "detection_plan": {
+    "bug_pattern":         "High-level description of the vulnerability pattern (e.g. 'heap buffer overflow when reading variable-length data into a fixed-size stack buffer without size bound')",
+    "report_condition":    "When should the checker emit a warning? (e.g. 'call to gf_strdup where the argument originates from a fixed-size local array that was populated by variable-length bitstream reads')",
+    "safe_condition":      "When should the checker NOT emit a warning? (e.g. 'argument originates from a heap allocation or a size-bounded source')",
+    "source_level_signal": "What AST / MemRegion / SVal property does the checker look for? (e.g. 'MemRegion extent < parameter size at a PreCall to gf_strdup')"
+  },
+  "api_choice": {
+    "mechanism_level":          "syntactic_ast | control_flow | path_sensitive | interprocedural_dataflow",
+    "callback":                 "check::PreCall | check::PostCall | check::PreStmt | check::PostStmt | check::Bind | check::DeadSymbols | check::EndFunction | ...",
+    "reasoning":                "Why this callback and its AST/state/CFG evidence prove the report and safe conditions",
+    "alternatives_considered":  ["check::PostCall"]
+  },
+  "implementation": {
+    "scope_level":    "patch_specific | project_general | cross_project",
+    "checker_name":   "project.CheckerName",
+    "build_attempts": 1
+  }
+}
+```
+
+### ``summary.json``
+
+```json
+{
+  "status":           "plausible | failed",
+  "bug_pattern":      "One sentence describing the bug pattern",
+  "scope_level":      "patch_specific | project_general | cross_project",
+  "checker_cpp":      "checker.cpp",
+  "checker_so":       "checker.so",
+  "n_buggy":          0,
+  "n_patched":        0,
+  "total_reports":    0,
+  "fp_rate_estimate": 0.0,
+  "failure_reason":   null
+}
+```
+
+## Feedback-derived requirements for this fresh synthesis
+
+A prior independent rollout exposed the risks below. Start again from the patch
+in this new session. Do not reconstruct, edit, or assume the prior checker.
+
+Required mechanism level: `path_sensitive`
+
+### Current failure diagnosis
+
+- The rollout proved the syntactic sequence of memory load, blocking call, and later dereference, but did not prove that synchronization or ownership protection had been relinquished so that the pointee could actually be freed.
+- Treating every memory-loaded local pointer as stale after any classified blocking call was semantically broader than the CVE and exposed false-positive risk for pointers protected by a live lock, reference, or refcount.
+- The refinement round ended with feedback_required, so the proposed scope and transfer rules were not accepted as clean or converged.
+- Process quality remained below threshold because project scans were repeated after parse failures without resolving the missing-header or invalid-flag environment, even though later harness validation supplied successful differential evidence.
+- The 10-before and 0-after result demonstrated patch discrimination, but patch discrimination alone did not establish the use-after-free root cause required by semantic_mechanism.
+
+### Preserve from prior rollouts
+
+- Preserve successful checker compilation, before/after validation, and code verification.
+- Preserve objective eligibility gate G6.
+- Preserve semantic score at or above the configured threshold.
+- Do not introduce dependence on changed lines, patch anchors, or diagnostic proximity to the patch.
+- Do not introduce patch-local hardcoding such as jbd2 function, field, type, file, or line names.
+
+### Required semantic proof
+
+- Track a pointer value loaded from shared mutable memory and retain its identity through relevant local copies along an analyzed execution path.
+- Establish that the protection relevant to that shared pointer is relinquished before a scheduling or blocking operation, creating the concurrency window identified by the patch evidence.
+- Require a feasible path from the original load through the protection-release and scheduling window to a dereference of the same cached value.
+- Report only when no reload from the shared memory location replaces the cached value after the last qualifying scheduling window and before the dereference on that path.
+- Treat a reload after the release-schedule-reacquire cycle as the safety operation demonstrated by the patched loop.
+- Exclude cases where path evidence shows that protection or a live ownership/reference guarantee remains effective across the blocking operation.
+
+### Implementation constraints
+
+- Use path-sensitive CSA callbacks and ProgramState traits to represent cached-value origin, relevant protection or ownership status, exposure to a qualifying scheduling window, and replacement by reload.
+- Model assignments and initializers through bind or equivalent expression-value events so facts follow the pointer value through local copies and are killed when overwritten by an unrelated value.
+- Observe direct scheduling/blocking calls and relevant protection transitions in statement callbacks; do not mark every live pointer stale merely because a function contains a blocking call.
+- Recognize dereference sinks including member access through a pointer, unary dereference, array subscripting, and address-taking of a member used in call arguments.
+- Keep the analysis intraprocedural unless the required event is directly represented in the current exploded path; do not claim a callee-side free has been proven when only a generic call name was observed.
+- Emit a path-sensitive report at the stale dereference, with supporting load and qualifying scheduling-window events when CSA path diagnostics can represent them.
+- Keep scope project-general by using semantic AST types, regions, symbols, and documented kernel synchronization or scheduling APIs rather than patch-specific identifiers.
+
+### Validation checklist
+
+- Build the fresh checker plugin successfully against the supplied Clang Static Analyzer API and verify registration under the intended checker name.
+- Resolve the project parsing environment before scanning; confirm both supplied source versions are analyzed with no skipped files or compile errors.
+- Scan the vulnerable source and require diagnostics for the stale transaction value that survives the lock-release and schedule cycle to the later dereference.
+- Scan the patched source and require no diagnostic because each loop iteration reloads j_running_transaction after the prior scheduling cycle.
+- Verify the primary diagnostic is located at the stale dereference in jbd2_journal_wait_updates, with load and scheduling-window events represented as supporting path context rather than separate warnings.
+- Add focused cases for no blocking call, reload after blocking, unrelated overwrite, local or parameter origin, local-copy propagation, and dereferences nested in call arguments.
+- Add refinement cases where a lock or live reference remains protective across a wait and require no report, addressing the semantic false-positive concern.
+- Re-run differential and code verification and retain the observed eligibility properties: vulnerable presence, patched cleanliness, relevant disappearance, and no unrelated disappearance.
+
+### Avoid and forbidden regressions
+
+- Do not repeat a function-wide AST or CFG may-analysis that marks all cached pointers crossed after any blocking primitive without path-specific protection evidence.
+- Do not equate sleeping or scheduling by itself with proof that an arbitrary pointee can be freed.
+- Do not use diagnostic disappearance in the patched revision as a substitute for proving pointer identity, exposure, and missing reload.
+- Do not report at the load, lock operation, or blocking call when the vulnerability manifests at the later stale dereference.
+- Do not infer safety from a reload on only some alternate path; the analyzed reporting path must still carry the old value to the sink.
+- Do not broaden scheduling primitive lists or exclude APIs solely to tune this patch's warning count.
+- Do not repeat scans after parser failure without first correcting and verifying the compilation flags and header environment.
+- Do not rely on the prior checker implementation as an artifact to edit, repair, resume, reconstruct, or copy.

tasks/csa159/pair_165550/checker_template.cpp

@@ -0,0 +1,98 @@
+// ============================================================================
+// CSA Checker Template
+// ============================================================================
+// Fill in the sections marked with TODO to implement your checker.
+// The checker is compiled with -fno-rtti to match the LLVM 18 build config.
+// It is loaded via: clang -cc1 -load checker.so -analyzer-checker=your.CheckerName
+//
+// Compilation:
+//   clang++ -std=c++17 -fPIC -shared -fno-rtti -fno-exceptions \
+//           -I${LLVM_BUILD_DIR}/include \
+//           checker.cpp -o checker.so \
+//           -Wl,--allow-shlib-undefined
+//
+// Usage:
+//   clang -cc1 -load ./checker.so -analyzer-checker=your.CheckerName -analyze <file>
+// ============================================================================
+
+#include "clang/StaticAnalyzer/Core/BugReporter/BugReporter.h"
+#include "clang/StaticAnalyzer/Core/BugReporter/BugType.h"
+#include "clang/StaticAnalyzer/Core/Checker.h"
+#include "clang/StaticAnalyzer/Core/PathSensitive/CallEvent.h"
+#include "clang/StaticAnalyzer/Core/PathSensitive/CheckerContext.h"
+#include "clang/StaticAnalyzer/Frontend/CheckerRegistry.h"
+
+using namespace clang;
+using namespace ento;
+
+namespace {
+
+// ────────────────────────────────────────────────────────────────
+// TODO: Rename this class to describe your checker's purpose.
+// ────────────────────────────────────────────────────────────────
+class {{CHECKER_CLASS_NAME}}
+    : public Checker<check::PreCall,      // for checking before function calls
+                     check::PostCall>     // for checking after function calls
+{
+  // TODO: Customize the bug type name and category.
+  mutable std::unique_ptr<BugType> BT;
+
+public:
+  {{CHECKER_CLASS_NAME}}()
+      : BT(new BugType(this, "{{BUG_NAME}}", "{{BUG_CATEGORY}}")) {}
+
+  // ── PreCall callback (fires before every function call) ──────
+  void checkPreCall(const CallEvent &Call, CheckerContext &C) const {
+    // TODO: Implement your pre-call analysis logic here.
+    //
+    // Common patterns:
+    //
+    // 1. Check if the called function matches a specific name:
+    //    if (Call.getCalleeIdentifier()) {
+    //      StringRef name = Call.getCalleeIdentifier()->getName();
+    //      if (name == "target_function") { ... }
+    //    }
+    //
+    // 2. Get the program state:
+    //    ProgramStateRef State = C.getState();
+    //
+    // 3. Get arguments:
+    //    SVal Arg = Call.getArgSVal(0);
+    //
+    // 4. Generate a bug report:
+    //    ExplodedNode *ErrNode = C.generateErrorNode();
+    //    if (ErrNode) {
+    //      auto R = std::make_unique<PathSensitiveBugReport>(
+    //          *BT, "Description of the bug", ErrNode);
+    //      C.emitReport(std::move(R));
+    //    }
+  }
+
+  // ── PostCall callback (fires after every function call) ─────
+  void checkPostCall(const CallEvent &Call, CheckerContext &C) const {
+    // TODO: Implement your post-call analysis logic here.
+    //
+    // Common pattern — check the return value:
+    //   SVal RetVal = Call.getReturnValue();
+    //   if (RetVal.isUnknownOrUndef()) return;
+    //
+    //   ProgramStateRef State = C.getState();
+    //   // Modify state based on post-call conditions...
+  }
+};
+
+} // anonymous namespace
+
+// ────────────────────────────────────────────────────────────────
+// Registration — DO NOT modify the function signatures.
+// ────────────────────────────────────────────────────────────────
+
+extern "C" void clang_registerCheckers(CheckerRegistry &registry) {
+  registry.addChecker<{{CHECKER_CLASS_NAME}}>(
+      "{{CHECKER_FULL_NAME}}",  // e.g., "your.NullDereferenceChecker"
+      "{{CHECKER_DESC}}",       // e.g., "Detects null pointer dereference"
+      "{{CHECKER_DOC_URI}}");   // e.g., "https://example.com/docs"
+}
+
+extern "C" const char clang_analyzerAPIVersionString[] =
+    CLANG_ANALYZER_API_VERSION_STRING;