codejury 0.9.0__tar.gz → 0.10.0__tar.gz

{codejury-0.9.0 → codejury-0.10.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codejury
-Version: 0.9.0
+Version: 0.10.0
 Summary: General-purpose Application Security AI audit framework -- five-layer architecture, capabilities as first-class data
 Author: AISecLabs
 License-Expression: MIT
@@ -83,7 +83,7 @@ git diff | codejury audit --provider anthropic
 | `codejury run <task>` | Run a named task preset (see [Tasks](#tasks)). |
 | `codejury eval` | Score the golden cases; report precision / recall / F1, overall and per capability. |
 
-Shared flags: `--orchestrator {single,pipeline,debate,reflexion,challenge,taint}`,
+Shared flags: `--orchestrator {single,pipeline,debate,reflexion,challenge,taint,adaptive}`,
 `--provider {anthropic,openai,litellm}`, `--model`,
 `--format {text,markdown,json,sarif}`.
 
@@ -103,6 +103,11 @@ value reaching the sink is constant, sanitized, or trusted (using cross-file
 caller/callee context). It downgrades only on positive proof, so it removes false
 positives without dropping real findings.
 
+`--orchestrator adaptive` keeps cost down: it runs the single verifier first and
+escalates to a full debate only for artifacts worth it -- any VULNERABLE verdict
+(verify a flag before reporting) or a low-confidence PARTIAL/UNKNOWN one. Clean,
+confident files pay a single call; only the rest pay for debate.
+
 `--format sarif` emits a SARIF 2.1.0 log (validates against the official schema)
 for CI and security dashboards: each problem with a code location becomes a
 result carrying its capability (as the rule id), CWE, and a precise location.

{codejury-0.9.0 → codejury-0.10.0}/README.md

@@ -53,7 +53,7 @@ git diff | codejury audit --provider anthropic
 | `codejury run <task>` | Run a named task preset (see [Tasks](#tasks)). |
 | `codejury eval` | Score the golden cases; report precision / recall / F1, overall and per capability. |
 
-Shared flags: `--orchestrator {single,pipeline,debate,reflexion,challenge,taint}`,
+Shared flags: `--orchestrator {single,pipeline,debate,reflexion,challenge,taint,adaptive}`,
 `--provider {anthropic,openai,litellm}`, `--model`,
 `--format {text,markdown,json,sarif}`.
 
@@ -73,6 +73,11 @@ value reaching the sink is constant, sanitized, or trusted (using cross-file
 caller/callee context). It downgrades only on positive proof, so it removes false
 positives without dropping real findings.
 
+`--orchestrator adaptive` keeps cost down: it runs the single verifier first and
+escalates to a full debate only for artifacts worth it -- any VULNERABLE verdict
+(verify a flag before reporting) or a low-confidence PARTIAL/UNKNOWN one. Clean,
+confident files pay a single call; only the rest pay for debate.
+
 `--format sarif` emits a SARIF 2.1.0 log (validates against the official schema)
 for CI and security dashboards: each problem with a code location becomes a
 result carrying its capability (as the rule id), CWE, and a precise location.

{codejury-0.9.0 → codejury-0.10.0}/codejury/agents/verifier.py

@@ -93,16 +93,25 @@ def _build_prompt(path: str, content: str, cap: Capability, context: str = "") -
     )
 
 
-def _anti_pattern_cwes(cap: Capability) -> dict[str, str]:
-    """Map anti_pattern id -> CWE, so a verdict can inherit the CWE it matched."""
+_SEVERITY_RANK = {"CRITICAL": 4, "HIGH": 3, "MEDIUM": 2, "LOW": 1, "INFO": 0}
+
+
+def _anti_pattern_cwes(cap: Capability) -> dict[str, tuple[int, str]]:
+    """Map anti_pattern id -> (severity rank, CWE), so a verdict can inherit the CWE
+    of the most severe anti-pattern it matched (deterministic, not first-seen)."""
     return {
-        p.id: p.cwe
+        p.id: (_SEVERITY_RANK.get(p.severity, 2), p.cwe)
         for sub in cap.sub_capabilities.values()
         for p in sub.anti_patterns
         if p.cwe
     }
 
 
+def _resolve_cwe(matched_anti: list[str], cwe_by_id: dict[str, tuple[int, str]]) -> str:
+    matched = [cwe_by_id[a] for a in matched_anti if a in cwe_by_id]
+    return max(matched, key=lambda rank_cwe: rank_cwe[0])[1] if matched else ""
+
+
 def _parse_verdicts(text: str, cap: Capability) -> list[Verdict]:
     obj = extract_json_object(text)
     if not obj:
@@ -122,7 +131,7 @@ def _parse_verdicts(text: str, cap: Capability) -> list[Verdict]:
                 reasoning=str(v.get("reasoning", "")),
                 matched_correct=str_list(v.get("matched_correct")),
                 matched_anti=matched_anti,
-                cwe=next((cwe_by_id[a] for a in matched_anti if a in cwe_by_id), ""),
+                cwe=_resolve_cwe(matched_anti, cwe_by_id),
                 evidence=to_evidence(v.get("evidence")),
                 confidence=to_float(v.get("confidence"), 0.5),
             )

{codejury-0.9.0 → codejury-0.10.0}/codejury/analysis/provenance.py

@@ -72,7 +72,40 @@ def find_calls(scope: ast.AST, callee: str) -> list[ast.Call]:
 
 def trace_value(func: ast.FunctionDef | ast.AsyncFunctionDef, expr: ast.AST) -> Origin:
     """Trace where ``expr`` (an expression inside ``func``) gets its value from."""
-    return _classify(expr, _params(func), _assignments(func), frozenset())
+    params = _params(func)
+
+    def leaf(node: ast.AST, recurse) -> Origin:
+        if isinstance(node, ast.Call):
+            # the return value's provenance depends on the callee's semantics, which
+            # P1-03 decides with the vocabulary; here we just name the callee.
+            name = _call_name(node)
+            return Origin(calls=frozenset({name})) if name else _UNKNOWN
+        if isinstance(node, (ast.Attribute, ast.Subscript)):
+            dotted = _dotted(node)
+            origin = Origin(attrs=frozenset({dotted})) if dotted else _UNKNOWN
+            if _root_name(node) in params:  # e.g. request.args[...] where `request` is a parameter
+                origin = origin.merge(Origin(params=frozenset({_root_name(node)})))
+            return origin
+        return _UNKNOWN
+
+    return reduce_value(
+        expr,
+        params=params,
+        assigns=_assignments(func),
+        combine=_merge_origins,
+        leaf=leaf,
+        on_param=lambda n: Origin(params=frozenset({n})),
+        on_global=lambda n: Origin(globals_=frozenset({n})),
+        on_constant=lambda: _LITERAL,
+        on_cycle=Origin,  # assignment cycle -- no new information
+    )
+
+
+def _merge_origins(origins: list[Origin]) -> Origin:
+    out = Origin()
+    for o in origins:
+        out = out.merge(o)
+    return out
 
 
 def parameters(func: ast.FunctionDef | ast.AsyncFunctionDef) -> set[str]:
@@ -100,51 +133,63 @@ def access_root(node: ast.AST) -> str | None:
     return _root_name(node)
 
 
-def _classify(expr: ast.AST, params: set[str], assigns: dict[str, list[ast.AST]], seen: frozenset[str]) -> Origin:
+def reduce_value(
+    expr: ast.AST,
+    *,
+    params: set[str],
+    assigns: dict[str, list[ast.AST]],
+    combine,
+    leaf,
+    on_param,
+    on_global,
+    on_constant,
+    on_cycle,
+    seen: frozenset[str] = frozenset(),
+):
+    """Walk a value expression, folding it to a single result of the caller's type.
+
+    This is the structural recursion shared by provenance (P1-01) and taint
+    classification (P1-03): the composite forms that pass a value through (binops,
+    f-strings, conditionals, collections) and the local-name dispatch (parameter /
+    assignment chain / assignment cycle / free global) are handled here once. The
+    caller supplies the policy:
+
+    - ``combine(list)`` -> fold component results (also defines the empty result);
+    - ``on_constant() / on_param(name) / on_global(name) / on_cycle()`` -> leaf
+      results for a literal, a parameter, a free name, and an assignment cycle;
+    - ``leaf(node, recurse)`` -> everything else (calls, attribute/subscript
+      access, unmodelled nodes); ``recurse`` re-enters the walk for sub-expressions
+      (e.g. a taint propagator recursing into its arguments).
+    """
+
+    def recurse(e: ast.AST, _seen: frozenset[str] | None = None):
+        return reduce_value(
+            e, params=params, assigns=assigns, combine=combine, leaf=leaf,
+            on_param=on_param, on_global=on_global, on_constant=on_constant,
+            on_cycle=on_cycle, seen=seen if _seen is None else _seen,
+        )
+
     if isinstance(expr, ast.Constant):
-        return _LITERAL
+        return on_constant()
     if isinstance(expr, ast.JoinedStr):  # f-string: literal parts + interpolated exprs
-        origin = _LITERAL
-        for value in expr.values:
-            if isinstance(value, ast.FormattedValue):
-                origin = origin.merge(_classify(value.value, params, assigns, seen))
-        return origin
+        return combine([on_constant()] + [recurse(v.value) for v in expr.values if isinstance(v, ast.FormattedValue)])
     if isinstance(expr, ast.BinOp):
-        return _classify(expr.left, params, assigns, seen).merge(_classify(expr.right, params, assigns, seen))
-    if isinstance(expr, (ast.BoolOp,)):
-        return _merge_all(expr.values, params, assigns, seen)
-    if isinstance(expr, ast.IfExp):  # value is one branch or the other; the test does not flow in
-        return _classify(expr.body, params, assigns, seen).merge(_classify(expr.orelse, params, assigns, seen))
+        return combine([recurse(expr.left), recurse(expr.right)])
+    if isinstance(expr, ast.BoolOp):
+        return combine([recurse(v) for v in expr.values])
+    if isinstance(expr, ast.IfExp):  # one branch or the other; the test does not flow in
+        return combine([recurse(expr.body), recurse(expr.orelse)])
     if isinstance(expr, (ast.List, ast.Tuple, ast.Set)):
-        return _merge_all(expr.elts, params, assigns, seen)
-    if isinstance(expr, ast.Call):
-        # the return value's taint depends on the callee's semantics, which P1-03
-        # decides with the sanitizer/propagator catalog; here we just name the callee.
-        name = _call_name(expr)
-        return Origin(calls=frozenset({name})) if name else _UNKNOWN
-    if isinstance(expr, (ast.Attribute, ast.Subscript)):
-        dotted = _dotted(expr)
-        origin = Origin(attrs=frozenset({dotted})) if dotted else _UNKNOWN
-        root = _root_name(expr)
-        if root in params:  # e.g. request.args[...] where `request` is a parameter
-            origin = origin.merge(Origin(params=frozenset({root})))
-        return origin
+        return combine([recurse(e) for e in expr.elts])
     if isinstance(expr, ast.Name):
         if expr.id in seen:  # assignment cycle -- stop
-            return Origin()
+            return on_cycle()
         if expr.id in params:
-            return Origin(params=frozenset({expr.id}))
+            return on_param(expr.id)
         if expr.id in assigns:
-            return _merge_all(assigns[expr.id], params, assigns, seen | {expr.id})
-        return Origin(globals_=frozenset({expr.id}))  # module global, import, or builtin
-    return _UNKNOWN
-
-
-def _merge_all(exprs: list[ast.AST], params, assigns, seen) -> Origin:
-    origin = Origin()
-    for e in exprs:
-        origin = origin.merge(_classify(e, params, assigns, seen))
-    return origin
+            return combine([recurse(r, seen | {expr.id}) for r in assigns[expr.id]])
+        return on_global(expr.id)  # module global, import, or builtin
+    return leaf(expr, recurse)
 
 
 def _params(func: ast.AST) -> set[str]:

{codejury-0.9.0 → codejury-0.10.0}/codejury/analysis/taint.py

@@ -21,6 +21,7 @@ PARAM, for the cross-file caller hop (next) to resolve.
 from __future__ import annotations
 
 import ast
+import functools
 from dataclasses import dataclass
 from enum import Enum
 from pathlib import Path
@@ -34,6 +35,7 @@ from codejury.analysis.provenance import (
     callee,
     find_calls,
     parameters,
+    reduce_value,
 )
 from codejury.resources import TAINT_FILE
 
@@ -107,59 +109,55 @@ def taint_of(
 
     ``resolve_param`` is an optional ``(name) -> Taint`` callback; when given, a
     value that reaches a parameter is resolved through it (the cross-file caller
-    hop, P1-03b) instead of returning PARAM.
+    hop, P1-03b) instead of returning PARAM. Shares the structural recursion with
+    provenance via ``reduce_value``; this is the vocabulary-aware policy.
     """
-    return _walk(func, expr, vocab, assignments(func), parameters(func), frozenset(), resolve_param)
-
-
-def _walk(func, expr, vocab, assigns, params, seen, resolve) -> Taint:
-    def w(e):
-        return _walk(func, e, vocab, assigns, params, seen, resolve)
-
-    if isinstance(expr, ast.Constant):
-        return Taint.CONSTANT
-    if isinstance(expr, ast.JoinedStr):
-        return _combine([Taint.CONSTANT] + [w(v.value) for v in expr.values if isinstance(v, ast.FormattedValue)])
-    if isinstance(expr, ast.BinOp):
-        return _combine([w(expr.left), w(expr.right)])
-    if isinstance(expr, ast.BoolOp):
-        return _combine([w(v) for v in expr.values])
-    if isinstance(expr, ast.IfExp):
-        return _combine([w(expr.body), w(expr.orelse)])
-    if isinstance(expr, (ast.List, ast.Tuple, ast.Set)):
-        return _combine([w(e) for e in expr.elts] or [Taint.CONSTANT])
-    if isinstance(expr, ast.Call):
-        if _callee_in(expr, vocab.sanitizers):
-            return Taint.SANITIZED            # a sanitizer cleans its result regardless of input
-        if _callee_in(expr, vocab.sources):
-            return Taint.EXTERNAL             # e.g. input()
-        if _callee_in(expr, vocab.propagators) or _callee_in(expr, vocab.safe_sinks):
-            return _combine([w(a) for a in expr.args] or [Taint.CONSTANT])
-        return Taint.UNKNOWN                  # unknown call -- a cross-file hop may resolve it later
-    if isinstance(expr, (ast.Attribute, ast.Subscript)):
-        path = access_path(expr)
-        if path and _access_in(path, vocab.sources):
-            return Taint.EXTERNAL
-        if path and _access_in(path, vocab.trusted):
-            return Taint.TRUSTED
-        root = access_root(expr)
-        if root in params:                    # attribute of a parameter -- resolve at call site
-            return resolve(root) if resolve else Taint.PARAM
-        return Taint.UNKNOWN                  # unknown object attribute (e.g. self.x): not provably safe
-    if isinstance(expr, ast.Name):
-        if expr.id in seen:
-            return Taint.CONSTANT             # assignment cycle: no new information
-        if expr.id in params:
-            return resolve(expr.id) if resolve else Taint.PARAM
-        if expr.id in assigns:
-            return _combine([_walk(func, r, vocab, assigns, params, seen | {expr.id}, resolve)
-                             for r in assigns[expr.id]])
-        return Taint.TRUSTED                  # free module global / builtin -- conventionally a constant
-    return Taint.UNKNOWN
+    params = parameters(func)
+
+    def on_param(name: str) -> Taint:
+        return resolve_param(name) if resolve_param else Taint.PARAM
+
+    def leaf(node: ast.AST, recurse) -> Taint:
+        if isinstance(node, ast.Call):
+            if _callee_in(node, vocab.sanitizers):
+                return Taint.SANITIZED        # a sanitizer cleans its result regardless of input
+            if _callee_in(node, vocab.sources):
+                return Taint.EXTERNAL         # e.g. input()
+            # a method ON a source/trusted object, e.g. request.args.get("id")
+            func_path = access_path(node.func)
+            if func_path and _access_in(func_path, vocab.sources):
+                return Taint.EXTERNAL
+            if func_path and _access_in(func_path, vocab.trusted):
+                return Taint.TRUSTED
+            if _callee_in(node, vocab.propagators) or _callee_in(node, vocab.safe_sinks):
+                return _combine([recurse(a) for a in node.args])
+            return Taint.UNKNOWN              # unknown call -- a cross-file hop may resolve it later
+        if isinstance(node, (ast.Attribute, ast.Subscript)):
+            path = access_path(node)
+            if path and _access_in(path, vocab.sources):
+                return Taint.EXTERNAL
+            if path and _access_in(path, vocab.trusted):
+                return Taint.TRUSTED
+            if access_root(node) in params:   # attribute of a parameter -- resolve at the call site
+                return on_param(access_root(node))
+            return Taint.UNKNOWN              # unknown object attribute (e.g. self.x): not provably safe
+        return Taint.UNKNOWN
+
+    return reduce_value(
+        expr,
+        params=params,
+        assigns=assignments(func),
+        combine=_combine,
+        leaf=leaf,
+        on_param=on_param,
+        on_global=lambda n: Taint.TRUSTED,    # free module global / builtin -- conventionally a constant
+        on_constant=lambda: Taint.CONSTANT,
+        on_cycle=lambda: Taint.CONSTANT,      # assignment cycle: no new information
+    )
 
 
 def _combine(taints: list[Taint]) -> Taint:
-    return max(taints, key=lambda t: _RANK[t])
+    return max(taints, key=lambda t: _RANK[t]) if taints else Taint.CONSTANT
 
 
 def _callee_in(call: ast.Call, names: tuple[str, ...]) -> bool:
@@ -197,10 +195,11 @@ def taint_in_repo(
 
 
 def _caller_resolver(func, files, vocab):
+    sites = _call_sites(func.name, files)  # computed once, reused across parameters
     def resolve(param_name: str) -> Taint:
         index = _param_index(func, param_name)
         results = []
-        for scope, call in _call_sites(func.name, files):
+        for scope, call in sites:
             arg = _arg_for_param(call, index, param_name)
             # one hop only: classify the caller's argument without recursing further
             results.append(taint_of(scope, arg, vocab) if arg is not None else Taint.UNKNOWN)
@@ -210,6 +209,8 @@ def _caller_resolver(func, files, vocab):
 
 def _param_index(func, name: str) -> int | None:
     positional = [*func.args.posonlyargs, *func.args.args]
+    if positional and positional[0].arg in ("self", "cls"):
+        positional = positional[1:]  # bound-method call sites omit the receiver
     for i, arg in enumerate(positional):
         if arg.arg == name:
             return i
@@ -225,12 +226,21 @@ def _arg_for_param(call: ast.Call, index: int | None, name: str) -> ast.AST | No
     return None
 
 
+@functools.lru_cache(maxsize=256)
+def _parse(source: str) -> ast.Module | None:
+    """Parse a source string once and cache it (the same files are walked repeatedly
+    during cross-file resolution); None if it does not parse."""
+    try:
+        return ast.parse(source)
+    except SyntaxError:
+        return None
+
+
 def _call_sites(name: str, files: dict[str, str]) -> list[tuple[ast.AST, ast.Call]]:
     sites = []
     for source in files.values():
-        try:
-            tree = ast.parse(source)
-        except SyntaxError:
+        tree = _parse(source)
+        if tree is None:
             continue
         funcs = [n for n in ast.walk(tree) if isinstance(n, (ast.FunctionDef, ast.AsyncFunctionDef))]
         for call in find_calls(tree, name):
@@ -250,24 +260,27 @@ def worst_sink_taint(content: str, files: dict[str, str], vocab: TaintVocab) ->
 
     A "potential sink" is any call that is not a safe sink, sanitizer, or
     propagator (those are not where injection happens). Each such call's argument
-    taint is classified with the cross-file resolver, and the worst is returned.
-    ``Taint.CONSTANT`` when there is no sink to worry about; ``None`` when the
-    code does not parse (the caller should then not act).
-
-    Used by the taint gate to downgrade an input_validation finding only when the
-    whole artifact is provably clean -- so a single tainted sink keeps every
-    finding (recall preserved).
+    taint is classified with the cross-file resolver. A safe sink that consumes
+    tainted data (e.g. ``json.loads(request.data)``) contributes SANITIZED -- the
+    data was handled safely. The worst contribution is returned.
+
+    ``Taint.UNKNOWN`` when no inspectable sink is found (the artifact may still be
+    unsafe via a return value or an implicit sink, so it is NOT assumed clean);
+    ``None`` when the code does not parse. The taint gate downgrades a finding only
+    on a SAFE result, so an unproven artifact keeps its findings (recall preserved).
     """
-    try:
-        tree = ast.parse(content)
-    except SyntaxError:
+    tree = _parse(content)
+    if tree is None:
         return None
     funcs = [n for n in ast.walk(tree) if isinstance(n, (ast.FunctionDef, ast.AsyncFunctionDef))]
     taints: list[Taint] = []
     for call in [n for n in ast.walk(tree) if isinstance(n, ast.Call)]:
-        if is_safe_sink(call, vocab) or _callee_in(call, vocab.sanitizers) or _callee_in(call, vocab.propagators):
-            continue  # not a place an injection lands
+        if is_safe_sink(call, vocab):
+            taints.append(Taint.SANITIZED)  # tainted data consumed by a safe parser
+            continue
+        if _callee_in(call, vocab.sanitizers) or _callee_in(call, vocab.propagators):
+            continue  # not a sink itself; counted via the enclosing sink's argument
         scope = _enclosing_scope(funcs, call) or tree
         for arg in (*call.args, *(kw.value for kw in call.keywords)):
             taints.append(taint_in_repo(scope, arg, vocab, files))
-    return _combine(taints) if taints else Taint.CONSTANT
+    return _combine(taints) if taints else Taint.UNKNOWN

{codejury-0.9.0 → codejury-0.10.0}/codejury/assembly.py

@@ -18,6 +18,7 @@ from codejury.domain.context import AnalysisContext
 from codejury.domain.result import AnalysisResult
 from codejury.infrastructure.cache import VerdictCache, verdict_key
 from codejury.orchestrators.base import Orchestrator
+from codejury.orchestrators.adaptive import AdaptiveOrchestrator
 from codejury.orchestrators.challenge import ChallengeOrchestrator
 from codejury.orchestrators.debate import DebateOrchestrator
 from codejury.orchestrators.pipeline import PipelineOrchestrator
@@ -31,7 +32,7 @@ from codejury.providers.openai import OpenAIProvider
 from codejury.providers.retry import RetryProvider
 from codejury.sources.base import Source
 
-STRATEGIES = ("single", "pipeline", "debate", "reflexion", "challenge", "taint")
+STRATEGIES = ("single", "pipeline", "debate", "reflexion", "challenge", "taint", "adaptive")
 PROVIDERS = ("anthropic", "openai", "litellm")
 DEFAULT_MODEL = os.environ.get("CODEJURY_MODEL", "claude-sonnet-4-6")
 DEFAULT_API_BASE = os.environ.get("CODEJURY_API_BASE")
@@ -59,6 +60,11 @@ def build_orchestration(
         roles = (FinderAgent, ChallengerAgent, JudgeAgent)
         agents = {cls.role: cls(provider=provider, model=model, max_tokens=max_tokens) for cls in roles}
         return agents, DebateOrchestrator()
+    if strategy == "adaptive":
+        roles = (FinderAgent, ChallengerAgent, JudgeAgent)
+        agents = {cls.role: cls(provider=provider, model=model, max_tokens=max_tokens) for cls in roles}
+        agents["verifier"] = VerifierAgent(provider=provider, model=model, max_tokens=max_tokens)
+        return agents, AdaptiveOrchestrator()
     if strategy == "reflexion":
         agents = {
             "actor": FinderAgent(provider=provider, model=model, max_tokens=max_tokens),
@@ -79,9 +85,15 @@ def build_orchestration(
     return verifier, SingleOrchestrator()
 
 
-def orchestration_descriptor(strategy: str, model: str, max_tokens: int) -> str:
+def provider_tag(provider: Provider) -> str:
+    """A stable short name for a provider (unwrapping RetryProvider) for cache keys,
+    so two providers that accept the same model string do not share cached verdicts."""
+    return type(getattr(provider, "_inner", provider)).__name__
+
+
+def orchestration_descriptor(provider: Provider, strategy: str, model: str, max_tokens: int) -> str:
     """The non-code, non-capability inputs that affect a verdict, as a cache tag."""
-    return f"{strategy}|{model}|{max_tokens}"
+    return f"{provider_tag(provider)}|{strategy}|{model}|{max_tokens}"
 
 
 def run_over_artifacts(

{codejury-0.9.0 → codejury-0.10.0}/codejury/cli.py

@@ -79,7 +79,7 @@ def audit(
     agents, orchestrator = build_orchestration(strategy, provider=provider, model=model, max_tokens=max_tokens)
     return run_over_source(
         DiffSource(diff_text), capabilities, agents, orchestrator,
-        cache=cache, orchestration=orchestration_descriptor(strategy, model, max_tokens),
+        cache=cache, orchestration=orchestration_descriptor(provider, strategy, model, max_tokens),
     )
 
 
@@ -114,7 +114,7 @@ def scan(
     agents, orchestrator = build_orchestration(strategy, provider=provider, model=model, max_tokens=max_tokens)
     return run_over_artifacts(
         artifacts, capabilities, agents, orchestrator,
-        cache=cache, orchestration=orchestration_descriptor(strategy, model, max_tokens),
+        cache=cache, orchestration=orchestration_descriptor(provider, strategy, model, max_tokens),
     )
 
 

{codejury-0.9.0 → codejury-0.10.0}/codejury/evaluation.py

@@ -159,8 +159,19 @@ def evaluate(
             capabilities=[capability],
         )
         result = orchestrator.run(agents, ctx)
-        if result.error:  # e.g. a provider auth failure -- surface it, don't score blanks
-            raise RuntimeError(result.error)
-        predicted = any(getattr(o, "status", None) == "VULNERABLE" for o in result.observations)
+        if result.error:  # e.g. a provider auth failure -- surface it (with the case), don't score blanks
+            raise RuntimeError(f"case {case.name!r}: {result.error}")
+        predicted = _predicted_vulnerable(result.observations)
         report.record(case.capability, actual=case.vulnerable, predicted=predicted)
     return report
+
+
+def _predicted_vulnerable(observations: list) -> bool:
+    """Did the run flag a problem? A Finding (debate/reflexion) or a VULNERABLE
+    Verdict (single/pipeline/taint) counts; SECURE verdicts and dismissed
+    concessions do not. (A bare Finding has no ``status``, so checking only
+    status would score debate/reflexion as zero recall.)"""
+    return any(
+        o.kind == "finding" or (o.kind == "verdict" and getattr(o, "status", None) == "VULNERABLE")
+        for o in observations
+    )

codejury-0.10.0/codejury/orchestrators/adaptive.py

@@ -0,0 +1,55 @@
+"""AdaptiveOrchestrator -- cheap triage, deep debate only where it pays off.
+
+Most files are clean, and debate is several model calls; running it everywhere
+wastes them. So this runs the single verifier first, then escalates to a full
+Finder -> Challenger -> Judge debate only when the cheap pass found something
+worth a second opinion:
+
+- **high-risk**: any VULNERABLE verdict -- a flagged vulnerability is verified by
+  the adversarial pass before it is reported / gates CI;
+- **disputed**: a PARTIAL or UNKNOWN verdict the verifier is unsure about
+  (confidence below the threshold).
+
+A clean artifact (only confident SECURE / NOT_PRESENT verdicts) pays one verifier
+call and stops. An escalated artifact is handed to the debate, whose deeper
+ruling supersedes the triage verdicts for that artifact.
+"""
+
+from __future__ import annotations
+
+from codejury.agents.base import Agent
+from codejury.domain.context import AnalysisContext
+from codejury.domain.observation import Verdict
+from codejury.domain.result import AnalysisResult
+from codejury.orchestrators.base import Orchestrator
+from codejury.orchestrators.debate import DebateOrchestrator
+
+_DISPUTABLE = ("PARTIAL", "UNKNOWN")
+
+
+class AdaptiveOrchestrator(Orchestrator):
+    def __init__(self, *, confidence_threshold: float = 0.7, debate: DebateOrchestrator | None = None) -> None:
+        self._threshold = confidence_threshold
+        self._debate = debate if debate is not None else DebateOrchestrator()
+
+    def run(self, agents: dict[str, Agent], context: AnalysisContext) -> AnalysisResult:
+        if "verifier" not in agents:
+            return AnalysisResult(error="adaptive requires agents: verifier")
+        try:
+            verdicts = agents["verifier"].run(context)
+        except Exception as exc:
+            return AnalysisResult(error=f"agent 'verifier' failed: {exc}")
+
+        if not self._needs_escalation(verdicts):
+            return AnalysisResult(observations=verdicts)  # cheap path: confident, low-risk
+        return self._debate.run(agents, context)          # deep path supersedes the triage
+
+    def _needs_escalation(self, verdicts: list) -> bool:
+        for v in verdicts:
+            if not isinstance(v, Verdict):
+                continue
+            if v.status == "VULNERABLE":  # high-risk: verify a flagged vuln adversarially
+                return True
+            if v.status in _DISPUTABLE and v.confidence < self._threshold:  # disputed
+                return True
+        return False

{codejury-0.9.0 → codejury-0.10.0}/codejury/orchestrators/taint_gate.py

@@ -58,7 +58,7 @@ class TaintGateOrchestrator(Orchestrator):
         for v in verdicts:
             if (
                 isinstance(v, Verdict)
-                and v.status in ("VULNERABLE", "PARTIAL")
+                and v.status == "VULNERABLE"  # leave PARTIAL ("incomplete validation") signal intact
                 and v.capability.split(".")[0] in self._taint_capabilities
             ):
                 observations.append(

{codejury-0.9.0 → codejury-0.10.0}/codejury/reporting.py

@@ -9,8 +9,8 @@ dismissed.
 from __future__ import annotations
 
 import json
-from importlib.metadata import PackageNotFoundError, version
 
+from codejury import __version__ as _tool_version
 from codejury.domain.observation import Observation, observation_from_dict
 from codejury.domain.result import AnalysisResult
 
@@ -24,13 +24,6 @@ _PROBLEM_STATUSES = ("VULNERABLE", "PARTIAL")
 _SARIF_LEVEL = {"CRITICAL": "error", "HIGH": "error", "MEDIUM": "warning", "LOW": "note", "INFO": "note"}
 
 
-def _tool_version() -> str:
-    try:
-        return version("codejury")
-    except PackageNotFoundError:
-        return "0"
-
-
 def to_json(results: Results) -> str:
     payload = {
         "files": [
@@ -183,7 +176,7 @@ def to_sarif(results: Results) -> str:
                     "driver": {
                         "name": "codejury",
                         "informationUri": "https://github.com/aiseclabs/codejury",
-                        "version": _tool_version(),
+                        "version": _tool_version,
                         "rules": rules,
                     }
                 },