attackmap 0.4.21__tar.gz → 0.4.26__tar.gz

{attackmap-0.4.21/src/attackmap.egg-info → attackmap-0.4.26}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: attackmap
-Version: 0.4.21
+Version: 0.4.26
 Summary: AI-assisted defensive security analyzer for codebases — scans a repository, models assets and controls, finds cross-cutting weaknesses, and generates an evidence-grounded review with MITRE ATT&CK mappings and detection-engineering hints.
 Author: AttackMap Contributors
 Author-email: Matthew Davis <matthewd@matthewd.xyz>
@@ -128,6 +128,31 @@ model ID verbatim.
 Read `reports/defensive-review.md` (heuristic) and `reports/defensive-review-llm.md`
 (LLM-narrated) side by side.
 
+**Multi-repo (fleet) scan.** Pass two or more repositories to scan a whole fleet
+in one run:
+
+```bash
+attackmap analyze ./service-a ./service-b ./gateway --output reports
+```
+
+Each repo is scanned independently into its own `reports/<repo>/` directory, and
+a `reports/fleet-summary.md` (+ `.json`) indexes the run with per-repo severity
+counts and top findings. AttackMap then **links the seams**: it matches one
+repo's outbound HTTP calls to another repo's routes (by normalized path template
++ method — `base + "/api/orders/" + id` in a caller aligns with `/api/orders/{id}`
+served elsewhere), lists each client→server link (citing both sides) in the fleet
+summary, and renders the repo-to-repo graph to `reports/fleet-graph.md`.
+
+Over those links it then flags **cross-boundary trust** (confused-deputy) risks:
+a value one repo forwards across a link that the callee trusts into a dangerous
+sink or an unguarded object access — each repo looks locally fine; the bug is in
+the seam. These are marked **speculative** (leads to adjudicate, citing both the
+caller and callee sites) and listed in the fleet summary. It also flags
+**trust-assumption gaps** (a state-changing call crossing a link to a route the
+callee serves with no auth — if each side assumes the other enforces, nobody
+does) and **cross-repo anomalies** (the one service that omits an auth control
+its siblings enforce on the same route). Single-repo behavior is unchanged.
+
 ---
 
 ## Install
@@ -765,10 +790,12 @@ scaffolding, testing, and publishing instructions is in
 
 ```bash
 attackmap analyze <path>                 # run a review on a repository
+attackmap analyze repoA repoB gateway    # multi-repo fleet scan (per-repo reports + fleet summary)
 attackmap analyze <path> --output dir    # write outputs to `dir/`
 attackmap analyze <path> --format json   # json | markdown | all (default)
 attackmap analyze <path> --module python --module rust   # only these analyzers
 attackmap analyze <path> --cve           # cross-reference SBOM against OSV.dev
+attackmap analyze <path> --recall        # widen taint discovery (deeper hops, capability-reach); extra reach marked SPECULATIVE
 attackmap analyze <path> --llm           # add LLM narrative (auto-resolve auth)
 attackmap analyze <path> --llm --llm-backend cli         # force Claude CLI
 attackmap analyze <path> --llm --llm-provider openai     # use OpenAI/Codex (OPENAI_API_KEY or `codex` CLI)
@@ -778,6 +805,8 @@ attackmap analyze <path> --hunt --verify # adjudicate each lead vs. source (conf
 attackmap analyze <path> --hunt --verify --verify-votes 3   # majority vote of N independent skeptics (default 3; 1 = single pass)
 attackmap analyze <path> --hunt --verify --hunt-lenses 4     # N lens-specialised generation passes, deduped, then verified
 attackmap analyze <path> --hunt --verify --hunt-rounds 4     # loop-until-dry generation (completeness critic seeds each round)
+attackmap analyze <path> --hunt --verify --hunt-budget 500000  # cap total hunt output tokens across rounds
+attackmap analyze <path> --recall --hunt --verify   # widen the net, then adjudicate the speculative reach
 attackmap analyze <path> --remediate     # LLM review-first fix suggestions (remediation.md)
 attackmap analyze <path> --triage        # cluster/dedupe/rank existing findings (triage.md; deterministic fallback)
 attackmap analyze <path> --pr-comment pr.md   # Markdown PR summary comment for CI
@@ -824,7 +853,7 @@ introduces a new HIGH finding.
 
 ## Project status
 
-AttackMap is **beta** (v0.4.18) — published and validated on real codebases, but
+AttackMap is **beta** (v0.4.25) — published and validated on real codebases, but
 pre-1.0 and heuristic.
 
 **Solid today:**
@@ -842,13 +871,27 @@ pre-1.0 and heuristic.
 - BOLA/IDOR authorization detection (with custom-middleware / guard-arg awareness).
 - Insecure-crypto / weak-randomness (Python/JS/Go/PHP) and web-hardening
   (CORS/CSRF/cookies/CSP/debug) detection.
-- Anomaly / outlier detection and **exploitability fusion** — a deterministic,
-  explainable 0–100 "exploitable now" score that ranks route→sink combinations
-  and folds in known-vulnerable dependencies on the path.
-- **`--hunt`** (LLM exploit-chain hypotheses) with **`--verify`** (adjudicate
-  each lead CONFIRMED/REFUTED/NEEDS-REVIEW against the actual source),
-  **`--remediate`** (review-first fix suggestions), and **`--triage`**
-  (cluster/dedupe/rank existing findings, with a deterministic fallback).
+- Anomaly / outlier detection — including **signature-free invariant mining**
+  (flag the handler that reaches a dangerous sink without the guard its peers
+  apply) — and **exploitability fusion**, a deterministic, explainable 0–100
+  "exploitable now" score that ranks route→sink combinations and folds in
+  known-vulnerable dependencies on the path.
+- **`--hunt`** (LLM exploit-chain hypotheses) with a **verify jury** —
+  **`--verify`** adjudicates each lead CONFIRMED/REFUTED/NEEDS-REVIEW against the
+  actual source; **`--verify-votes`** runs N independent skeptics, **`--hunt-lenses`**
+  fans generation across failure-mode specialists, **`--hunt-rounds`** loops
+  until dry with a completeness critic, **`--hunt-budget`** caps token spend —
+  plus **`--remediate`** (review-first fixes) and **`--triage`**
+  (cluster/dedupe/rank existing findings, deterministic fallback).
+- **`--recall`** — verifier-gated aggressive discovery: widens the taint walk
+  (deeper hops, capability-reach enumeration of every reach to exec/fs/net/
+  deserialize/template/SQL) and marks the extra reach SPECULATIVE, kept out of
+  `--fail-on-new-high` and left for `--hunt --verify` to adjudicate.
+- **Cross-repo / fleet analysis** — `attackmap analyze repoA repoB …` scans a
+  fleet, links one repo's outbound HTTP calls to another's routes, and surfaces
+  bugs that live in the seams: cross-boundary (confused-deputy) flows,
+  trust-assumption gaps, and the sibling service that omits a control its peers
+  enforce. All cross-repo findings are speculative until verified.
 - SBOM inventory (5 ecosystems) + OSV.dev CVE cross-reference (`--cve`).
 - Output: Markdown + JSON + **SARIF 2.1.0** + **Mermaid / Graphviz** diagrams;
   **diff/baseline** PR gating; a reusable **GitHub Action + PR bot**; optional

{attackmap-0.4.21 → attackmap-0.4.26}/README.md

@@ -67,6 +67,31 @@ model ID verbatim.
 Read `reports/defensive-review.md` (heuristic) and `reports/defensive-review-llm.md`
 (LLM-narrated) side by side.
 
+**Multi-repo (fleet) scan.** Pass two or more repositories to scan a whole fleet
+in one run:
+
+```bash
+attackmap analyze ./service-a ./service-b ./gateway --output reports
+```
+
+Each repo is scanned independently into its own `reports/<repo>/` directory, and
+a `reports/fleet-summary.md` (+ `.json`) indexes the run with per-repo severity
+counts and top findings. AttackMap then **links the seams**: it matches one
+repo's outbound HTTP calls to another repo's routes (by normalized path template
++ method — `base + "/api/orders/" + id` in a caller aligns with `/api/orders/{id}`
+served elsewhere), lists each client→server link (citing both sides) in the fleet
+summary, and renders the repo-to-repo graph to `reports/fleet-graph.md`.
+
+Over those links it then flags **cross-boundary trust** (confused-deputy) risks:
+a value one repo forwards across a link that the callee trusts into a dangerous
+sink or an unguarded object access — each repo looks locally fine; the bug is in
+the seam. These are marked **speculative** (leads to adjudicate, citing both the
+caller and callee sites) and listed in the fleet summary. It also flags
+**trust-assumption gaps** (a state-changing call crossing a link to a route the
+callee serves with no auth — if each side assumes the other enforces, nobody
+does) and **cross-repo anomalies** (the one service that omits an auth control
+its siblings enforce on the same route). Single-repo behavior is unchanged.
+
 ---
 
 ## Install
@@ -704,10 +729,12 @@ scaffolding, testing, and publishing instructions is in
 
 ```bash
 attackmap analyze <path>                 # run a review on a repository
+attackmap analyze repoA repoB gateway    # multi-repo fleet scan (per-repo reports + fleet summary)
 attackmap analyze <path> --output dir    # write outputs to `dir/`
 attackmap analyze <path> --format json   # json | markdown | all (default)
 attackmap analyze <path> --module python --module rust   # only these analyzers
 attackmap analyze <path> --cve           # cross-reference SBOM against OSV.dev
+attackmap analyze <path> --recall        # widen taint discovery (deeper hops, capability-reach); extra reach marked SPECULATIVE
 attackmap analyze <path> --llm           # add LLM narrative (auto-resolve auth)
 attackmap analyze <path> --llm --llm-backend cli         # force Claude CLI
 attackmap analyze <path> --llm --llm-provider openai     # use OpenAI/Codex (OPENAI_API_KEY or `codex` CLI)
@@ -717,6 +744,8 @@ attackmap analyze <path> --hunt --verify # adjudicate each lead vs. source (conf
 attackmap analyze <path> --hunt --verify --verify-votes 3   # majority vote of N independent skeptics (default 3; 1 = single pass)
 attackmap analyze <path> --hunt --verify --hunt-lenses 4     # N lens-specialised generation passes, deduped, then verified
 attackmap analyze <path> --hunt --verify --hunt-rounds 4     # loop-until-dry generation (completeness critic seeds each round)
+attackmap analyze <path> --hunt --verify --hunt-budget 500000  # cap total hunt output tokens across rounds
+attackmap analyze <path> --recall --hunt --verify   # widen the net, then adjudicate the speculative reach
 attackmap analyze <path> --remediate     # LLM review-first fix suggestions (remediation.md)
 attackmap analyze <path> --triage        # cluster/dedupe/rank existing findings (triage.md; deterministic fallback)
 attackmap analyze <path> --pr-comment pr.md   # Markdown PR summary comment for CI
@@ -763,7 +792,7 @@ introduces a new HIGH finding.
 
 ## Project status
 
-AttackMap is **beta** (v0.4.18) — published and validated on real codebases, but
+AttackMap is **beta** (v0.4.25) — published and validated on real codebases, but
 pre-1.0 and heuristic.
 
 **Solid today:**
@@ -781,13 +810,27 @@ pre-1.0 and heuristic.
 - BOLA/IDOR authorization detection (with custom-middleware / guard-arg awareness).
 - Insecure-crypto / weak-randomness (Python/JS/Go/PHP) and web-hardening
   (CORS/CSRF/cookies/CSP/debug) detection.
-- Anomaly / outlier detection and **exploitability fusion** — a deterministic,
-  explainable 0–100 "exploitable now" score that ranks route→sink combinations
-  and folds in known-vulnerable dependencies on the path.
-- **`--hunt`** (LLM exploit-chain hypotheses) with **`--verify`** (adjudicate
-  each lead CONFIRMED/REFUTED/NEEDS-REVIEW against the actual source),
-  **`--remediate`** (review-first fix suggestions), and **`--triage`**
-  (cluster/dedupe/rank existing findings, with a deterministic fallback).
+- Anomaly / outlier detection — including **signature-free invariant mining**
+  (flag the handler that reaches a dangerous sink without the guard its peers
+  apply) — and **exploitability fusion**, a deterministic, explainable 0–100
+  "exploitable now" score that ranks route→sink combinations and folds in
+  known-vulnerable dependencies on the path.
+- **`--hunt`** (LLM exploit-chain hypotheses) with a **verify jury** —
+  **`--verify`** adjudicates each lead CONFIRMED/REFUTED/NEEDS-REVIEW against the
+  actual source; **`--verify-votes`** runs N independent skeptics, **`--hunt-lenses`**
+  fans generation across failure-mode specialists, **`--hunt-rounds`** loops
+  until dry with a completeness critic, **`--hunt-budget`** caps token spend —
+  plus **`--remediate`** (review-first fixes) and **`--triage`**
+  (cluster/dedupe/rank existing findings, deterministic fallback).
+- **`--recall`** — verifier-gated aggressive discovery: widens the taint walk
+  (deeper hops, capability-reach enumeration of every reach to exec/fs/net/
+  deserialize/template/SQL) and marks the extra reach SPECULATIVE, kept out of
+  `--fail-on-new-high` and left for `--hunt --verify` to adjudicate.
+- **Cross-repo / fleet analysis** — `attackmap analyze repoA repoB …` scans a
+  fleet, links one repo's outbound HTTP calls to another's routes, and surfaces
+  bugs that live in the seams: cross-boundary (confused-deputy) flows,
+  trust-assumption gaps, and the sibling service that omits a control its peers
+  enforce. All cross-repo findings are speculative until verified.
 - SBOM inventory (5 ecosystems) + OSV.dev CVE cross-reference (`--cve`).
 - Output: Markdown + JSON + **SARIF 2.1.0** + **Mermaid / Graphviz** diagrams;
   **diff/baseline** PR gating; a reusable **GitHub Action + PR bot**; optional

{attackmap-0.4.21 → attackmap-0.4.26}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "attackmap"
-version = "0.4.21"
+version = "0.4.26"
 description = "AI-assisted defensive security analyzer for codebases — scans a repository, models assets and controls, finds cross-cutting weaknesses, and generates an evidence-grounded review with MITRE ATT&CK mappings and detection-engineering hints."
 readme = "README.md"
 requires-python = ">=3.11"

{attackmap-0.4.21 → attackmap-0.4.26}/src/attackmap/__init__.py

@@ -1,2 +1,2 @@
 __all__ = ["__version__"]
-__version__ = "0.4.21"
+__version__ = "0.4.25"

{attackmap-0.4.21 → attackmap-0.4.26}/src/attackmap/analyzers.py

@@ -47,6 +47,7 @@ from .scanner import (
     DB_KEYWORDS,
     DB_PATTERNS,
     EXTERNAL_CALL_PATTERNS,
+    _external_call_fields,
     SECRET_PATTERNS,
     extract_routes,
     scan_repo,
@@ -104,7 +105,10 @@ class ExternalCallAnalyzer:
         calls: list[ExternalCall] = []
         for pattern in EXTERNAL_CALL_PATTERNS:
             for match in pattern.finditer(context.content):
-                calls.append(ExternalCall(target=match.groups()[-1], file=context.relative_path))
+                target, method = _external_call_fields(match)
+                calls.append(
+                    ExternalCall(target=target, method=method, file=context.relative_path)
+                )
         return AnalyzerSignals(external_calls=calls)
 
 

{attackmap-0.4.21 → attackmap-0.4.26}/src/attackmap/anomalies.py

@@ -195,6 +195,32 @@ def find_anomalies(
     return out
 
 
+def route_auth_signals(
+    scan: ScanResult, root: str | Path | None = None
+) -> dict[tuple[str, str, str], bool]:
+    """Per-route authentication/authorization presence for one repo.
+
+    Maps ``(file, method, path)`` → whether an auth/authorization marker appears
+    within that route handler's own span (the same span-bounded detection the
+    within-repo `auth_outlier` pass uses). Exposed for cross-repo trust analysis
+    (#146d): the fleet layer runs it per repo — each with its own root — to spot
+    an unauthenticated route reached across a service boundary, and the sibling
+    service that omits an auth control its peers enforce."""
+    root_path = Path(root or scan.root).resolve()
+    routes = [r for r in scan.routes if not is_test_file(r.file)]
+    line_cache: dict[str, list[str]] = {}
+    file_route_lines: dict[str, list[int]] = {}
+    for route in routes:
+        if route.line is not None:
+            file_route_lines.setdefault(route.file, []).append(route.line)
+    for lines in file_route_lines.values():
+        lines.sort()
+    ctx = _SignalCtx(root_path, line_cache, file_route_lines)
+    return {
+        (r.file, r.method, r.path): _route_has_signal(r, ctx, _AUTH_MARKERS) for r in routes
+    }
+
+
 # --- Heuristics ------------------------------------------------------------
 
 
@@ -608,4 +634,4 @@ def _file_lines(rel_file: str, ctx: _SignalCtx) -> list[str]:
     return lines
 
 
-__all__ = ["find_anomalies"]
+__all__ = ["find_anomalies", "route_auth_signals"]

{attackmap-0.4.21 → attackmap-0.4.26}/src/attackmap/cli.py

@@ -17,6 +17,21 @@ from .analyzers import (
     select_requested_analyzers,
 )
 from .cve import query_vulnerabilities
+from .anomalies import route_auth_signals
+from .contracts import link_contracts
+from .crossrepo import (
+    find_cross_boundary_flows,
+    find_cross_repo_anomalies,
+    find_trust_gaps,
+)
+from .fleet import (
+    FleetRepoResult,
+    FleetScan,
+    fleet_repo_ids,
+    fleet_summary_json,
+    render_fleet_graph_mermaid,
+    render_fleet_summary,
+)
 from .diff import (
     FindingSnapshot,
     diff_findings,
@@ -66,9 +81,151 @@ TRIAGE_BANNER = (
 )
 
 
+def _run_fleet(
+    repo_paths: list[Path],
+    *,
+    output: str,
+    module: list[str] | None,
+    recall: bool,
+    cve: bool,
+    no_suppress: bool,
+    suppress_file: str | None,
+    progress_format: str,
+    no_progress: bool,
+    fleet_incompatible: dict[str, bool],
+) -> None:
+    """Multi-repo fleet scan (#146a). Scans each repo independently — reusing the
+    same building blocks a single-repo run uses — writes per-repo reports into
+    ``output/<repo_id>/``, and assembles a fleet summary. No cross-repo detection
+    yet (that is #146b–#146d); this is the foundation."""
+    active_flags = [flag for flag, on in fleet_incompatible.items() if on]
+    if active_flags:
+        raise typer.BadParameter(
+            f"{', '.join(sorted(active_flags))} not yet supported in multi-repo mode — "
+            "run one repository at a time for these (fleet-aware wiring lands in #146b+)."
+        )
+
+    selected_analyzers = None
+    if module:
+        try:
+            selected_analyzers = select_requested_analyzers(module, auto_install=True)
+        except ValueError as exc:
+            raise typer.BadParameter(str(exc)) from exc
+
+    output_root = Path(output)
+    repo_ids = fleet_repo_ids(repo_paths)
+    fleet = FleetScan()
+
+    for repo_id, repo_path in zip(repo_ids, repo_paths):
+        typer.echo("")
+        typer.echo(f"── {repo_id}  ({repo_path}) ──")
+        active_analyzers = resolve_run_analyzers(repo_path, analyzers=selected_analyzers)
+        scan_progress = create_progress(progress_format, no_progress=no_progress)
+        scan = analyze_repository(
+            repo_path, analyzers=active_analyzers, progress=scan_progress, recall=recall
+        )
+        if cve and scan.dependencies:
+            try:
+                vulns, _cve_summary = query_vulnerabilities(scan.dependencies)
+            finally:
+                scan_progress.done()
+            scan.vulnerabilities = vulns
+
+        graph = build_graph(scan)
+        analysis = translate_recon(scan)
+        attack_surfaces = analysis.attack_surfaces
+        findings = analysis.findings
+        attack_paths = analysis.attack_paths
+        architecture_md = summarize_architecture(scan, graph)
+        attack_surface_md = summarize_attack_surface(scan, attack_surfaces)
+
+        suppressed_findings: list = []
+        if not no_suppress:
+            explicit = Path(suppress_file) if suppress_file else None
+            if explicit is not None and not explicit.exists():
+                raise typer.BadParameter(f"Suppress file not found: {explicit}")
+            suppset, sup_warnings = collect_suppressions(repo_path, findings, explicit_file=explicit)
+            for warning in sup_warnings:
+                typer.echo(f"Suppression warning: {warning}", err=True)
+            outcome = apply_suppressions(findings, suppset)
+            findings = outcome.active
+            suppressed_findings = outcome.suppressed
+
+        defensive_review_md = render_defensive_review(scan, attack_surfaces, findings, attack_paths)
+        repo_out = output_root / repo_id
+        write_reports(
+            repo_out,
+            scan,
+            architecture_md,
+            attack_surface_md,
+            defensive_review_md,
+            attack_surfaces,
+            findings,
+            attack_paths,
+            analyzer_metadata=[
+                {
+                    "name": metadata.name,
+                    "description": metadata.description,
+                    "scope": metadata.scope,
+                    "ecosystems": list(metadata.ecosystems),
+                }
+                for metadata in (get_analyzer_metadata(a) for a in active_analyzers)
+            ],
+            suppressed=suppressed_findings,
+        )
+        typer.echo(render_console_summary(scan, findings, attack_paths))
+        fleet.results.append(
+            FleetRepoResult(
+                repo_id=repo_id,
+                root=str(repo_path),
+                report_dir=str(repo_out.resolve()),
+                scan=scan,
+                findings=findings,
+                attack_paths=attack_paths,
+                suppressed_count=len(suppressed_findings),
+            )
+        )
+
+    # Cross-repo contract linking (#146b): match one repo's outbound calls to
+    # another repo's routes, over the assembled fleet.
+    repo_scans = [(r.repo_id, r.scan) for r in fleet.results]
+    fleet.links = link_contracts(repo_scans)
+    # Cross-boundary trust flows (#146c): confused-deputy leads over the links.
+    fleet.cross_boundary = find_cross_boundary_flows(fleet.links, repo_scans)
+    # Trust-assumption gaps + cross-repo anomalies (#146d / #149b). Per-route auth
+    # signals are resolved per repo (each with its own root).
+    auth_by_repo = {r.repo_id: route_auth_signals(r.scan, r.root) for r in fleet.results}
+    fleet.trust_gaps = find_trust_gaps(fleet.links, repo_scans, auth_by_repo)
+    fleet.cross_repo_anomalies = find_cross_repo_anomalies(repo_scans, auth_by_repo)
+
+    output_root.mkdir(parents=True, exist_ok=True)
+    (output_root / "fleet-summary.md").write_text(
+        render_fleet_summary(fleet) + "\n", encoding="utf-8"
+    )
+    (output_root / "fleet-summary.json").write_text(
+        json.dumps(fleet_summary_json(fleet), indent=2) + "\n", encoding="utf-8"
+    )
+    (output_root / "fleet-graph.md").write_text(
+        render_fleet_graph_mermaid(fleet) + "\n", encoding="utf-8"
+    )
+    typer.echo("")
+    typer.echo(
+        f"Fleet: {fleet.repo_count} repositories, {fleet.total_findings()} finding(s), "
+        f"{len(fleet.links)} cross-repo link(s), "
+        f"{len(fleet.cross_boundary)} cross-boundary + {len(fleet.trust_gaps)} trust-gap + "
+        f"{len(fleet.cross_repo_anomalies)} anomaly (all speculative). "
+        f"Summary written to: {(output_root / 'fleet-summary.md').resolve()}"
+    )
+
+
 @app.command()
 def analyze(
-    path: str = typer.Argument(".", help="Path to the repository to analyze."),
+    paths: list[str] | None = typer.Argument(
+        None,
+        help="Path(s) to the repository(ies) to analyze. Pass two or more for a "
+        "cross-repo fleet scan (#146a): each is scanned into its own report "
+        "subdirectory and a fleet summary is written alongside. Defaults to '.'.",
+    ),
     output: str = typer.Option("reports", "--output", "-o", help="Directory for generated reports."),
     format: str = typer.Option("all", "--format", help="Output format: all, markdown, or json."),
     module: list[str] | None = typer.Option(
@@ -198,9 +355,45 @@ def analyze(
         help="Path to a suppression baseline, overriding auto-discovery of .attackmap-suppress.yaml at the repo root (#144).",
     ),
 ) -> None:
-    repo_path = Path(path).resolve()
-    if not repo_path.exists():
-        raise typer.BadParameter(f"Path does not exist: {repo_path}")
+    repo_paths = [Path(p).resolve() for p in (paths or ["."])]
+    for rp in repo_paths:
+        if not rp.exists():
+            raise typer.BadParameter(f"Path does not exist: {rp}")
+
+    # Validate progress format before either branch, so the fleet path enforces
+    # the same option semantics as a single-repo run (#146a).
+    if progress_format not in {"auto", "tty", "json", "none"}:
+        raise typer.BadParameter("--progress-format must be one of: auto, json, none.")
+
+    # Multi-repo fleet mode (#146a): scan each repo independently and assemble a
+    # fleet view. Dispatched here so the single-repo path below is untouched.
+    if len(repo_paths) > 1:
+        _run_fleet(
+            repo_paths,
+            output=output,
+            module=module,
+            recall=recall,
+            cve=cve,
+            no_suppress=no_suppress,
+            suppress_file=suppress_file,
+            progress_format=progress_format,
+            no_progress=no_progress,
+            # Single-repo-only features aren't fleet-aware yet — reject rather
+            # than silently ignore, so the user isn't surprised (#146b+ wire them).
+            fleet_incompatible={
+                "--baseline": baseline is not None,
+                "--diff-output": diff_output is not None,
+                "--fail-on-new-high": fail_on_new_high,
+                "--pr-comment": pr_comment is not None,
+                "--llm": llm,
+                "--hunt": hunt,
+                "--remediate": remediate,
+                "--triage": triage,
+            },
+        )
+        return
+
+    repo_path = repo_paths[0]
     # Validate diff-mode flag combinations before doing any real work.
     if fail_on_new_high and baseline is None:
         raise typer.BadParameter("--fail-on-new-high requires --baseline to be set.")
@@ -216,8 +409,7 @@ def analyze(
         except ValueError as exc:
             raise typer.BadParameter(str(exc)) from exc
 
-    if progress_format not in {"auto", "tty", "json", "none"}:
-        raise typer.BadParameter("--progress-format must be one of: auto, json, none.")
+    # (--progress-format is validated up-front, before the fleet dispatch.)
     if llm_speed not in {"standard", "fast"}:
         raise typer.BadParameter("--llm-speed must be one of: standard, fast.")
     if llm_provider not in {"claude", "openai"}: