@cubis/foundry 0.3.10

package/Ai Agent Workflow/workflows/agent-environment-setup/platforms/cursor/skills/semgrep/references/rulesets.md

@@ -0,0 +1,162 @@
+# Semgrep Rulesets Reference
+
+## Complete Ruleset Catalog
+
+### Security-Focused Rulesets
+
+| Ruleset | Description | Use Case |
+|---------|-------------|----------|
+| `p/security-audit` | Comprehensive vulnerability detection, higher false positives | Manual audits, security reviews |
+| `p/secrets` | Hardcoded credentials, API keys, tokens | Always include |
+| `p/owasp-top-ten` | OWASP Top 10 web application vulnerabilities | Web app security |
+| `p/cwe-top-25` | CWE Top 25 most dangerous software weaknesses | General security |
+| `p/sql-injection` | SQL injection patterns and tainted data flows | Database security |
+| `p/insecure-transport` | Ensures code uses encrypted channels | Network security |
+| `p/gitleaks` | Hard-coded credentials detection (gitleaks port) | Secrets scanning |
+| `p/findsecbugs` | FindSecBugs rule pack for Java | Java security |
+| `p/phpcs-security-audit` | PHP security audit rules | PHP security |
+
+### CI/CD Rulesets
+
+| Ruleset | Description | Use Case |
+|---------|-------------|----------|
+| `p/default` | Default ruleset, balanced coverage | First-time users |
+| `p/ci` | High-confidence security + logic bugs, low FP | CI pipelines |
+| `p/r2c-ci` | Low false positives, CI-safe | CI/CD blocking |
+| `p/r2c` | Community favorite, curated by Semgrep (618k+ downloads) | General scanning |
+| `p/auto` | Auto-selects rules based on detected languages/frameworks | Quick scans |
+| `p/comment` | Comment-related rules | Code review |
+
+### Third-Party Rulesets
+
+| Ruleset | Description | Maintainer |
+|---------|-------------|------------|
+| `p/gitlab` | GitLab-maintained security rules | GitLab |
+
+---
+
+## Ruleset Selection Algorithm
+
+Follow this algorithm to select rulesets based on detected languages and frameworks.
+
+### Step 1: Always Include Security Baseline
+
+```json
+{
+  "baseline": ["p/security-audit", "p/secrets"]
+}
+```
+
+- `p/security-audit` - Comprehensive vulnerability detection (always include)
+- `p/secrets` - Hardcoded credentials, API keys, tokens (always include)
+
+### Step 2: Add Language-Specific Rulesets
+
+For each detected language, add the primary ruleset. If a framework is detected, add its ruleset too.
+
+**GA Languages (production-ready):**
+
+| Detection | Primary Ruleset | Framework Rulesets | Pro Rule Count |
+|-----------|-----------------|-------------------|----------------|
+| `.py` | `p/python` | `p/django`, `p/flask`, `p/fastapi` | 710+ |
+| `.js`, `.jsx` | `p/javascript` | `p/react`, `p/nodejs`, `p/express`, `p/nextjs`, `p/angular` | 250+ (JS), 70+ (JSX) |
+| `.ts`, `.tsx` | `p/typescript` | `p/react`, `p/nodejs`, `p/express`, `p/nextjs`, `p/angular` | 230+ |
+| `.go` | `p/golang` | `p/go` (alias) | 80+ |
+| `.java` | `p/java` | `p/spring`, `p/findsecbugs` | 190+ |
+| `.kt` | `p/kotlin` | `p/spring` | 60+ |
+| `.rb` | `p/ruby` | `p/rails` | 40+ |
+| `.php` | `p/php` | `p/symfony`, `p/laravel`, `p/phpcs-security-audit` | 50+ |
+| `.c`, `.cpp`, `.h` | `p/c` | - | 150+ |
+| `.rs` | `p/rust` | - | 40+ |
+| `.cs` | `p/csharp` | - | 170+ |
+| `.scala` | `p/scala` | - | Community |
+| `.swift` | `p/swift` | - | 60+ |
+
+**Beta Languages (Pro recommended):**
+
+| Detection | Primary Ruleset | Notes |
+|-----------|-----------------|-------|
+| `.ex`, `.exs` | `p/elixir` | Requires Pro for best coverage |
+| `.cls`, `.trigger` | `p/apex` | Salesforce; requires Pro |
+
+**Experimental Languages:**
+
+| Detection | Primary Ruleset | Notes |
+|-----------|-----------------|-------|
+| `.sol` | No official ruleset | Use Decurity third-party rules |
+| `Dockerfile` | `p/dockerfile` | Limited rules |
+| `.yaml`, `.yml` | `p/yaml` | K8s, GitHub Actions, docker-compose patterns |
+| `.json` | `r/json.aws` | AWS IAM policies; use `r/json.*` for specific rules |
+| Bash scripts | - | Community support |
+| Cairo, Circom | - | Experimental, smart contracts |
+
+**Framework detection hints:**
+
+| Framework | Detection Signals | Ruleset |
+|-----------|------------------|---------|
+| Django | `settings.py`, `urls.py`, `django` in requirements | `p/django` |
+| Flask | `flask` in requirements, `@app.route` | `p/flask` |
+| FastAPI | `fastapi` in requirements, `@app.get/post` | `p/fastapi` |
+| React | `package.json` with react dependency, `.jsx`/`.tsx` files | `p/react` |
+| Next.js | `next.config.js`, `pages/` or `app/` directory | `p/nextjs` |
+| Angular | `angular.json`, `@angular/` dependencies | `p/angular` |
+| Express | `express` in package.json, `app.use()` patterns | `p/express` |
+| NestJS | `@nestjs/` dependencies, `@Controller` decorators | `p/nodejs` |
+| Spring | `pom.xml` with spring, `@SpringBootApplication` | `p/spring` |
+| Rails | `Gemfile` with rails, `config/routes.rb` | `p/rails` |
+| Laravel | `composer.json` with laravel, `artisan` | `p/laravel` |
+| Symfony | `composer.json` with symfony, `config/packages/` | `p/symfony` |
+
+### Step 3: Add Infrastructure Rulesets
+
+| Detection | Ruleset | Description |
+|-----------|---------|-------------|
+| `Dockerfile` | `p/dockerfile` | Container security, best practices |
+| `.tf`, `.hcl` | `p/terraform` | IaC misconfigurations, CIS benchmarks, AWS/Azure/GCP |
+| k8s manifests | `p/kubernetes` | K8s security, RBAC issues |
+| CloudFormation | `p/cloudformation` | AWS infrastructure security |
+| GitHub Actions | `p/github-actions` | CI/CD security, secrets exposure |
+| `.yaml`, `.yml` | `p/yaml` | Generic YAML patterns (K8s, docker-compose) |
+| AWS IAM JSON | `r/json.aws` | IAM policy misconfigurations (use `--config r/json.aws`) |
+
+### Step 4: Add Third-Party Rulesets
+
+These are **NOT optional**. Include automatically when language matches:
+
+| Languages | Source | Why Required |
+|-----------|--------|--------------|
+| Python, Go, Ruby, JS/TS, Terraform, HCL | [Trail of Bits](https://github.com/trailofbits/semgrep-rules) | Security audit patterns from real engagements (AGPLv3) |
+| C, C++ | [0xdea](https://github.com/0xdea/semgrep-rules) | Memory safety, low-level vulnerabilities |
+| Solidity, Cairo, Rust | [Decurity](https://github.com/Decurity/semgrep-smart-contracts) | Smart contract vulnerabilities, DeFi exploits |
+| Go | [dgryski](https://github.com/dgryski/semgrep-go) | Additional Go-specific patterns |
+| Android (Java/Kotlin) | [MindedSecurity](https://github.com/mindedsecurity/semgrep-rules-android-security) | OWASP MASTG-derived mobile security rules |
+| Java, Go, JS/TS, C#, Python, PHP | [elttam](https://github.com/elttam/semgrep-rules) | Security consulting patterns |
+| Dockerfile, PHP, Go, Java | [kondukto](https://github.com/kondukto-io/semgrep-rules) | Container and web app security |
+| PHP, Kotlin, Java | [dotta](https://github.com/federicodotta/semgrep-rules) | Pentest-derived web/mobile app rules |
+| Terraform, HCL | [HashiCorp](https://github.com/hashicorp-forge/semgrep-rules) | HashiCorp infrastructure patterns |
+| Swift, Java, Cobol | [akabe1](https://github.com/akabe1/akabe1-semgrep-rules) | iOS and legacy system patterns |
+| Java | [Atlassian Labs](https://github.com/atlassian-labs/atlassian-sast-ruleset) | Atlassian-maintained Java rules |
+| Python, JS/TS, Java, Ruby, Go, PHP | [Apiiro](https://github.com/apiiro/malicious-code-ruleset) | Malicious code detection, supply chain |
+
+### Step 5: Verify Rulesets
+
+Before finalizing, verify official rulesets load:
+
+```bash
+# Quick validation (exits 0 if valid)
+semgrep --config p/python --validate --metrics=off 2>&1 | head -3
+```
+
+Or browse the [Semgrep Registry](https://semgrep.dev/explore).
+
+### Output Format
+
+```json
+{
+  "baseline": ["p/security-audit", "p/secrets"],
+  "python": ["p/python", "p/django"],
+  "javascript": ["p/javascript", "p/react", "p/nodejs"],
+  "docker": ["p/dockerfile"],
+  "third_party": ["https://github.com/trailofbits/semgrep-rules"]
+}
+```

package/Ai Agent Workflow/workflows/agent-environment-setup/platforms/cursor/skills/semgrep/references/scanner-task-prompt.md

@@ -0,0 +1,102 @@
+# Scanner Subagent Task Prompt
+
+Use this prompt template when spawning scanner Tasks in Step 4. Use `subagent_type: Bash`.
+
+## Template
+
+```
+You are a Semgrep scanner for [LANGUAGE_CATEGORY].
+
+## Task
+Run Semgrep scans for [LANGUAGE] files and save results to [OUTPUT_DIR].
+
+## Pro Engine Status: [PRO_AVAILABLE: true/false]
+
+## APPROVED RULESETS (from user-confirmed plan)
+[LIST EXACT RULESETS USER APPROVED - DO NOT SUBSTITUTE]
+
+Example:
+- p/python
+- p/django
+- p/security-audit
+- p/secrets
+- https://github.com/trailofbits/semgrep-rules
+
+## Commands to Run (in parallel)
+
+### Generate commands for EACH approved ruleset:
+```bash
+semgrep [--pro if available] --metrics=off --config [RULESET] --json -o [OUTPUT_DIR]/[lang]-[ruleset].json --sarif-output=[OUTPUT_DIR]/[lang]-[ruleset].sarif [TARGET] &
+```
+
+Wait for all to complete:
+```bash
+wait
+```
+
+## Critical Rules
+- Use ONLY the rulesets listed above - do not add or remove any
+- Always use --metrics=off (prevents sending telemetry to Semgrep servers)
+- Use --pro when Pro is available (enables cross-file taint tracking)
+- Run all rulesets in parallel with & and wait
+- For GitHub URLs, clone the repo first if not cached locally
+
+## Output
+Report:
+- Number of findings per ruleset
+- Any scan errors
+- File paths of JSON results
+- [If Pro] Note any cross-file findings detected
+```
+
+## Variable Substitutions
+
+| Variable | Description | Example |
+|----------|-------------|---------|
+| `[LANGUAGE_CATEGORY]` | Language group being scanned | Python, JavaScript, Docker |
+| `[LANGUAGE]` | Specific language | Python, TypeScript, Go |
+| `[OUTPUT_DIR]` | Results directory with run number | semgrep-results-001 |
+| `[PRO_AVAILABLE]` | Whether Pro engine is available | true, false |
+| `[RULESET]` | Semgrep ruleset identifier | p/python, https://github.com/... |
+| `[TARGET]` | Directory to scan | . (current dir) |
+
+## Example: Python Scanner Task
+
+```
+You are a Semgrep scanner for Python.
+
+## Task
+Run Semgrep scans for Python files and save results to semgrep-results-001.
+
+## Pro Engine Status: true
+
+## APPROVED RULESETS (from user-confirmed plan)
+- p/python
+- p/django
+- p/security-audit
+- p/secrets
+- https://github.com/trailofbits/semgrep-rules
+
+## Commands to Run (in parallel)
+```bash
+semgrep --pro --metrics=off --config p/python --json -o semgrep-results-001/python-python.json --sarif-output=semgrep-results-001/python-python.sarif . &
+semgrep --pro --metrics=off --config p/django --json -o semgrep-results-001/python-django.json --sarif-output=semgrep-results-001/python-django.sarif . &
+semgrep --pro --metrics=off --config p/security-audit --json -o semgrep-results-001/python-security-audit.json --sarif-output=semgrep-results-001/python-security-audit.sarif . &
+semgrep --pro --metrics=off --config p/secrets --json -o semgrep-results-001/python-secrets.json --sarif-output=semgrep-results-001/python-secrets.sarif . &
+semgrep --pro --metrics=off --config https://github.com/trailofbits/semgrep-rules --json -o semgrep-results-001/python-trailofbits.json --sarif-output=semgrep-results-001/python-trailofbits.sarif . &
+wait
+```
+
+## Critical Rules
+- Use ONLY the rulesets listed above - do not add or remove any
+- Always use --metrics=off
+- Use --pro when Pro is available
+- Run all rulesets in parallel with & and wait
+
+## Output
+Report:
+- Number of findings per ruleset
+- Any scan errors
+- File paths of JSON results
+- Note any cross-file findings detected
+```

package/Ai Agent Workflow/workflows/agent-environment-setup/platforms/cursor/skills/semgrep/references/triage-task-prompt.md

@@ -0,0 +1,122 @@
+# Triage Subagent Task Prompt
+
+Use this prompt template when spawning triage Tasks in Step 5. Use `subagent_type: general-purpose`.
+
+## Template
+
+```
+You are a security finding triager for [LANGUAGE_CATEGORY].
+
+## Input Files
+[LIST OF JSON FILES TO TRIAGE]
+
+## Output Directory
+[OUTPUT_DIR]
+
+## Task
+For each finding:
+1. Read the JSON finding
+2. Read source code context (5 lines before/after)
+3. Classify as TRUE_POSITIVE or FALSE_POSITIVE
+
+## False Positive Criteria
+- Test files (should add to .semgrepignore)
+- Sanitized inputs (context shows validation)
+- Dead code paths
+- Example/documentation code
+- Already has nosemgrep comment
+
+## Output Format
+Create: [OUTPUT_DIR]/[lang]-triage.json
+
+```json
+{
+  "file": "[lang]-[ruleset].json",
+  "total": 45,
+  "true_positives": [
+    {"rule": "...", "file": "...", "line": N, "reason": "..."}
+  ],
+  "false_positives": [
+    {"rule": "...", "file": "...", "line": N, "reason": "..."}
+  ]
+}
+```
+
+## Report
+Return summary:
+- Total findings: N
+- True positives: N
+- False positives: N (with breakdown by reason)
+```
+
+## Variable Substitutions
+
+| Variable | Description | Example |
+|----------|-------------|---------|
+| `[LANGUAGE_CATEGORY]` | Language group being triaged | Python, JavaScript, Docker |
+| `[OUTPUT_DIR]` | Results directory with run number | semgrep-results-001 |
+
+## Example: Python Triage Task
+
+```
+You are a security finding triager for Python.
+
+## Input Files
+- semgrep-results-001/python-python.json
+- semgrep-results-001/python-django.json
+- semgrep-results-001/python-security-audit.json
+- semgrep-results-001/python-secrets.json
+- semgrep-results-001/python-trailofbits.json
+
+## Output Directory
+semgrep-results-001
+
+## Task
+For each finding:
+1. Read the JSON finding
+2. Read source code context (5 lines before/after)
+3. Classify as TRUE_POSITIVE or FALSE_POSITIVE
+
+## False Positive Criteria
+- Test files (should add to .semgrepignore)
+- Sanitized inputs (context shows validation)
+- Dead code paths
+- Example/documentation code
+- Already has nosemgrep comment
+
+## Output Format
+Create: semgrep-results-001/python-triage.json
+
+```json
+{
+  "file": "python-django.json",
+  "total": 45,
+  "true_positives": [
+    {"rule": "python.django.security.injection.sql-injection", "file": "views.py", "line": 42, "reason": "User input directly in raw SQL query"}
+  ],
+  "false_positives": [
+    {"rule": "python.django.security.injection.sql-injection", "file": "tests/test_views.py", "line": 15, "reason": "Test file with mock data"}
+  ]
+}
+```
+
+## Report
+Return summary:
+- Total findings: 45
+- True positives: 12
+- False positives: 33 (18 test files, 10 sanitized inputs, 5 dead code)
+```
+
+## Triage Decision Tree
+
+```
+Finding
+├── Is it in a test file? → FALSE_POSITIVE (add to .semgrepignore)
+├── Is it in example/docs? → FALSE_POSITIVE
+├── Does it have nosemgrep comment? → FALSE_POSITIVE (already acknowledged)
+├── Is the input sanitized/validated upstream?
+│   └── Check 10-20 lines before for validation → FALSE_POSITIVE if validated
+├── Is the code path reachable?
+│   └── Check if function is called/exported → FALSE_POSITIVE if dead code
+└── None of the above → TRUE_POSITIVE
+```

package/Ai Agent Workflow/workflows/agent-environment-setup/platforms/cursor/skills/semgrep/scripts/merge_triaged_sarif.py

@@ -0,0 +1,252 @@
+# /// script
+# requires-python = ">=3.11"
+# dependencies = []
+# ///
+"""Merge and filter SARIF files to include only triaged true positives.
+
+Usage:
+    uv run merge_triaged_sarif.py OUTPUT_DIR
+
+Reads *-triage.json and *.sarif files from OUTPUT_DIR, produces
+OUTPUT_DIR/findings-triaged.sarif containing only true positives.
+
+Attempts to use SARIF Multitool for merging if available, falls back to
+pure Python implementation.
+"""
+
+from __future__ import annotations
+
+import json
+import shutil
+import subprocess
+import sys
+import tempfile
+from pathlib import Path
+
+
+def load_true_positives(triage_dir: Path) -> set[tuple[str, str, int]]:
+    """Load true positives from all triage files as (rule_id, file, line) tuples."""
+    true_positives: set[tuple[str, str, int]] = set()
+
+    for triage_file in triage_dir.glob("*-triage.json"):
+        try:
+            data = json.loads(triage_file.read_text())
+        except json.JSONDecodeError as e:
+            print(f"Warning: Failed to parse {triage_file}: {e}", file=sys.stderr)
+            continue
+
+        for tp in data.get("true_positives", []):
+            rule = tp.get("rule", "")
+            file_path = tp.get("file", "")
+            line = tp.get("line", 0)
+            if rule and file_path and line:
+                true_positives.add((rule, file_path, line))
+
+    return true_positives
+
+
+def extract_result_key(result: dict) -> tuple[str, str, int] | None:
+    """Extract (rule_id, file, line) from a SARIF result."""
+    rule_id = result.get("ruleId", "")
+    locations = result.get("locations", [])
+    if not locations:
+        return None
+
+    phys_loc = locations[0].get("physicalLocation", {})
+    artifact_loc = phys_loc.get("artifactLocation", {})
+    uri = artifact_loc.get("uri", "")
+    region = phys_loc.get("region", {})
+    line = region.get("startLine", 0)
+
+    if not (rule_id and uri and line):
+        return None
+
+    return (rule_id, uri, line)
+
+
+def normalize_file_path(uri: str) -> str:
+    """Normalize file path for matching (handle relative vs absolute)."""
+    if uri.startswith("file://"):
+        uri = uri[7:]
+    return uri.lstrip("./")
+
+
+def has_sarif_multitool() -> bool:
+    """Check if SARIF Multitool is pre-installed via npx."""
+    if not shutil.which("npx"):
+        return False
+    try:
+        result = subprocess.run(
+            ["npx", "--no-install", "@microsoft/sarif-multitool", "--version"],
+            capture_output=True,
+            timeout=30,
+        )
+        return result.returncode == 0
+    except (subprocess.TimeoutExpired, OSError):
+        return False
+
+
+def merge_with_multitool(sarif_dir: Path) -> dict | None:
+    """Use SARIF Multitool to merge SARIF files. Returns merged SARIF or None."""
+    sarif_files = list(sarif_dir.glob("*.sarif"))
+    if not sarif_files:
+        return None
+
+    with tempfile.NamedTemporaryFile(suffix=".sarif", delete=False) as tmp:
+        tmp_path = Path(tmp.name)
+
+    try:
+        cmd = [
+            "npx",
+            "--no-install",
+            "@microsoft/sarif-multitool",
+            "merge",
+            *[str(f) for f in sarif_files],
+            "--output-file",
+            str(tmp_path),
+            "--force",
+        ]
+        result = subprocess.run(cmd, capture_output=True, timeout=120)
+        if result.returncode != 0:
+            print(f"SARIF Multitool merge failed: {result.stderr.decode()}", file=sys.stderr)
+            return None
+
+        return json.loads(tmp_path.read_text())
+    except (subprocess.TimeoutExpired, json.JSONDecodeError, OSError) as e:
+        print(f"SARIF Multitool error: {e}", file=sys.stderr)
+        return None
+    finally:
+        tmp_path.unlink(missing_ok=True)
+
+
+def merge_sarif_pure_python(sarif_dir: Path) -> dict:
+    """Pure Python SARIF merge (fallback)."""
+    merged = {
+        "version": "2.1.0",
+        "$schema": "https://json.schemastore.org/sarif-2.1.0.json",
+        "runs": [],
+    }
+
+    seen_rules: dict[str, dict] = {}
+    all_results: list[dict] = []
+    tool_info: dict | None = None
+
+    for sarif_file in sarif_dir.glob("*.sarif"):
+        try:
+            data = json.loads(sarif_file.read_text())
+        except json.JSONDecodeError as e:
+            print(f"Warning: Failed to parse {sarif_file}: {e}", file=sys.stderr)
+            continue
+
+        for run in data.get("runs", []):
+            if tool_info is None and run.get("tool"):
+                tool_info = run["tool"]
+
+            driver = run.get("tool", {}).get("driver", {})
+            for rule in driver.get("rules", []):
+                rule_id = rule.get("id", "")
+                if rule_id and rule_id not in seen_rules:
+                    seen_rules[rule_id] = rule
+
+            all_results.extend(run.get("results", []))
+
+    if all_results:
+        merged_run = {
+            "tool": tool_info or {"driver": {"name": "semgrep", "rules": []}},
+            "results": all_results,
+        }
+        merged_run["tool"]["driver"]["rules"] = list(seen_rules.values())
+        merged["runs"].append(merged_run)
+
+    return merged
+
+
+def filter_sarif_by_triage(sarif: dict, true_positives: set[tuple[str, str, int]]) -> dict:
+    """Filter SARIF results to include only triaged true positives."""
+    normalized_tps: set[tuple[str, str, int]] = set()
+    for rule, file_path, line in true_positives:
+        normalized_tps.add((rule, normalize_file_path(file_path), line))
+
+    filtered = {
+        "version": sarif.get("version", "2.1.0"),
+        "$schema": sarif.get("$schema", "https://json.schemastore.org/sarif-2.1.0.json"),
+        "runs": [],
+    }
+
+    for run in sarif.get("runs", []):
+        filtered_results = []
+        for result in run.get("results", []):
+            key = extract_result_key(result)
+            if key is None:
+                continue
+
+            rule_id, uri, line = key
+            normalized_key = (rule_id, normalize_file_path(uri), line)
+
+            if normalized_key in normalized_tps:
+                filtered_results.append(result)
+
+        if filtered_results:
+            result_rule_ids = {r.get("ruleId") for r in filtered_results}
+            driver = run.get("tool", {}).get("driver", {})
+            filtered_rules = [r for r in driver.get("rules", []) if r.get("id") in result_rule_ids]
+
+            filtered_run = {
+                "tool": {
+                    "driver": {
+                        **driver,
+                        "rules": filtered_rules,
+                    }
+                },
+                "results": filtered_results,
+            }
+            filtered["runs"].append(filtered_run)
+
+    return filtered
+
+
+def main() -> int:
+    if len(sys.argv) != 2:
+        print(f"Usage: {sys.argv[0]} OUTPUT_DIR", file=sys.stderr)
+        return 1
+
+    output_dir = Path(sys.argv[1])
+    if not output_dir.is_dir():
+        print(f"Error: {output_dir} is not a directory", file=sys.stderr)
+        return 1
+
+    # Load true positives from triage files
+    true_positives = load_true_positives(output_dir)
+    if not true_positives:
+        print("Warning: No true positives found in triage files", file=sys.stderr)
+
+    print(f"Found {len(true_positives)} true positives from triage")
+
+    # Try SARIF Multitool first, fall back to pure Python
+    merged: dict | None = None
+    if has_sarif_multitool():
+        print("Using SARIF Multitool for merge...")
+        merged = merge_with_multitool(output_dir)
+        if merged:
+            print("SARIF Multitool merge successful")
+
+    if merged is None:
+        print("Using pure Python merge (SARIF Multitool not available or failed)")
+        merged = merge_sarif_pure_python(output_dir)
+
+    # Filter to true positives only
+    filtered = filter_sarif_by_triage(merged, true_positives)
+
+    result_count = sum(len(run.get("results", [])) for run in filtered.get("runs", []))
+    print(f"Filtered SARIF contains {result_count} true positives")
+
+    # Write output
+    output_file = output_dir / "findings-triaged.sarif"
+    output_file.write_text(json.dumps(filtered, indent=2))
+    print(f"Written to {output_file}")
+
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())