codejury 0.10.0__tar.gz → 0.10.2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codejury
-Version: 0.10.0
+Version: 0.10.2
 Summary: General-purpose Application Security AI audit framework -- five-layer architecture, capabilities as first-class data
 Author: AISecLabs
 License-Expression: MIT
@@ -32,22 +32,22 @@ Dynamic: license-file
 
 An AI security auditor for code whose knowledge lives in versioned YAML, not in
 prompts. It reviews a diff or a whole repository against the OWASP ASVS and
-reports a verdict per dimension -- both what is **vulnerable** and what is
+reports a verdict per dimension: both what is **vulnerable** and what is
 **verified safe**.
 
-The name is the core idea: code goes before a "jury" of adversarial roles --
-Finder / Challenger / Judge -- that argue and converge on a verdict.
+The name is the core idea: code goes before a "jury" of adversarial roles,
+Finder / Challenger / Judge, that argue and converge on a verdict.
 
 Why it is built this way:
 
 - **Knowledge is data.** Each OWASP ASVS area (and now OWASP LLM Top 10 areas) is a YAML capability
-  (safe patterns + anti-patterns, with CWE and examples) -- versioned, reviewable
+  (safe patterns + anti-patterns, with CWE and examples), versioned, reviewable
   in a PR, and editable by non-engineers. The framework core stays small.
 - **Verdicts, not just alerts.** Every capability yields `SECURE` / `VULNERABLE`
   / `PARTIAL` / `NOT_PRESENT`, so a report shows what was checked and *passed*,
   not only what failed.
 - **Composable.** Four orchestration strategies, four model backends, and
-  diff / repo inputs are chosen per run -- mix and match.
+  diff / repo inputs are chosen per run; mix and match.
 
 ## Install
 
@@ -65,7 +65,7 @@ git diff origin/main... | codejury audit --fail-on high -
 # Post inline review comments on a GitHub pull request (needs GITHUB_TOKEN)
 git diff origin/main... | codejury audit --github your-org/your-repo#123 -
 
-# No API key needed -- prove the pipeline runs end to end with mock layers
+# No API key needed: prove the pipeline runs end to end with mock layers
 codejury dry-run
 
 # A real audit: set a key, then review your staged changes
@@ -104,7 +104,7 @@ caller/callee context). It downgrades only on positive proof, so it removes fals
 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
+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.
 
@@ -118,7 +118,7 @@ outside C/C++) are dropped by versioned rules in
 
 `codejury eval` takes `--dataset <dir>` (golden YAML directory), `--split <name>`
 (score only cases tagged with that `split:`, e.g. a held-out set), and
-`--format {text,json}` -- the JSON report is a stable schema (overall plus
+`--format {text,json}`; the JSON report is a stable schema (overall plus
 per-capability confusion matrix and precision / recall / F1).
 
 Runs are deterministic: providers query at temperature 0, and `audit` / `scan`
@@ -139,7 +139,7 @@ codejury scan ./myrepo --only secrets,input_validation,crypto
 ## Configuration
 
 Provider keys are read from the environment (codejury does **not** auto-load
-`.env` -- copy `.env.example` and `source` it):
+`.env`; copy `.env.example` and `source` it):
 
 | Variable | Used by |
 |---|---|
@@ -180,7 +180,7 @@ what `--only` and a task's `capabilities:` accept:
 `business_logic` · `dependency_config` · `prompt_injection` ·
 `insecure_output_handling` · `excessive_agency`
 
-To tune for your codebase, edit these files (add patterns / sharpen wording) --
+To tune for your codebase, edit these files (add patterns / sharpen wording);
 no code change needed.
 
 ## Architecture
@@ -210,13 +210,13 @@ independently.
   can't see whether a value is attacker-controlled. Mitigations that add context
   but do not fully solve it: `scan --callers` (where this file's functions are
   called) and `scan --callees` (the called code it delegates to, so a sink in
-  another file is visible) -- pair them for both directions; `--orchestrator
+  another file is visible); pair them for both directions; `--orchestrator
   challenge` (a recall-safe
   refutation pass that drops only provably-safe flags); `--only` to scope; or
   `--orchestrator debate`. Real taint precision still needs data-flow analysis,
   not model skepticism.
 - **`scan` cost scales as files x capabilities.** It is a periodic deep audit,
-  not a quick check -- scope it with `--only`. Day to day, audit the diff.
+  not a quick check; scope it with `--only`. Day to day, audit the diff.
 
 ## Development
 

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

@@ -2,22 +2,22 @@
 
 An AI security auditor for code whose knowledge lives in versioned YAML, not in
 prompts. It reviews a diff or a whole repository against the OWASP ASVS and
-reports a verdict per dimension -- both what is **vulnerable** and what is
+reports a verdict per dimension: both what is **vulnerable** and what is
 **verified safe**.
 
-The name is the core idea: code goes before a "jury" of adversarial roles --
-Finder / Challenger / Judge -- that argue and converge on a verdict.
+The name is the core idea: code goes before a "jury" of adversarial roles,
+Finder / Challenger / Judge, that argue and converge on a verdict.
 
 Why it is built this way:
 
 - **Knowledge is data.** Each OWASP ASVS area (and now OWASP LLM Top 10 areas) is a YAML capability
-  (safe patterns + anti-patterns, with CWE and examples) -- versioned, reviewable
+  (safe patterns + anti-patterns, with CWE and examples), versioned, reviewable
   in a PR, and editable by non-engineers. The framework core stays small.
 - **Verdicts, not just alerts.** Every capability yields `SECURE` / `VULNERABLE`
   / `PARTIAL` / `NOT_PRESENT`, so a report shows what was checked and *passed*,
   not only what failed.
 - **Composable.** Four orchestration strategies, four model backends, and
-  diff / repo inputs are chosen per run -- mix and match.
+  diff / repo inputs are chosen per run; mix and match.
 
 ## Install
 
@@ -35,7 +35,7 @@ git diff origin/main... | codejury audit --fail-on high -
 # Post inline review comments on a GitHub pull request (needs GITHUB_TOKEN)
 git diff origin/main... | codejury audit --github your-org/your-repo#123 -
 
-# No API key needed -- prove the pipeline runs end to end with mock layers
+# No API key needed: prove the pipeline runs end to end with mock layers
 codejury dry-run
 
 # A real audit: set a key, then review your staged changes
@@ -74,7 +74,7 @@ caller/callee context). It downgrades only on positive proof, so it removes fals
 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
+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.
 
@@ -88,7 +88,7 @@ outside C/C++) are dropped by versioned rules in
 
 `codejury eval` takes `--dataset <dir>` (golden YAML directory), `--split <name>`
 (score only cases tagged with that `split:`, e.g. a held-out set), and
-`--format {text,json}` -- the JSON report is a stable schema (overall plus
+`--format {text,json}`; the JSON report is a stable schema (overall plus
 per-capability confusion matrix and precision / recall / F1).
 
 Runs are deterministic: providers query at temperature 0, and `audit` / `scan`
@@ -109,7 +109,7 @@ codejury scan ./myrepo --only secrets,input_validation,crypto
 ## Configuration
 
 Provider keys are read from the environment (codejury does **not** auto-load
-`.env` -- copy `.env.example` and `source` it):
+`.env`; copy `.env.example` and `source` it):
 
 | Variable | Used by |
 |---|---|
@@ -150,7 +150,7 @@ what `--only` and a task's `capabilities:` accept:
 `business_logic` · `dependency_config` · `prompt_injection` ·
 `insecure_output_handling` · `excessive_agency`
 
-To tune for your codebase, edit these files (add patterns / sharpen wording) --
+To tune for your codebase, edit these files (add patterns / sharpen wording);
 no code change needed.
 
 ## Architecture
@@ -180,13 +180,13 @@ independently.
   can't see whether a value is attacker-controlled. Mitigations that add context
   but do not fully solve it: `scan --callers` (where this file's functions are
   called) and `scan --callees` (the called code it delegates to, so a sink in
-  another file is visible) -- pair them for both directions; `--orchestrator
+  another file is visible); pair them for both directions; `--orchestrator
   challenge` (a recall-safe
   refutation pass that drops only provably-safe flags); `--only` to scope; or
   `--orchestrator debate`. Real taint precision still needs data-flow analysis,
   not model skepticism.
 - **`scan` cost scales as files x capabilities.** It is a periodic deep audit,
-  not a quick check -- scope it with `--only`. Day to day, audit the diff.
+  not a quick check; scope it with `--only`. Day to day, audit the diff.
 
 ## Development
 

{codejury-0.10.0 → codejury-0.10.2}/codejury/__init__.py

@@ -1,6 +1,6 @@
-"""codejury -- a general-purpose Application Security AI audit framework.
+"""codejury: a general-purpose Application Security AI audit framework.
 
-Five layers: Task / (Capability + Orchestrator + Source + Agent) / Provider / Infrastructure.
+Five layers: Task, then Capability plus Orchestrator plus Source plus Agent, then Provider, then Infrastructure.
 Domain knowledge lives in YAML capability files as a first-class citizen,
 aligned with OWASP ASVS.
 """

{codejury-0.10.0 → codejury-0.10.2}/codejury/agents/__init__.py

@@ -1,4 +1,4 @@
-"""codejury.agents -- the audit roles (finder / challenger / judge / verifier).
+"""codejury.agents: the audit roles (finder / challenger / judge / verifier).
 
 An agent reads an AnalysisContext and emits observations. It talks to a model
 only through a Provider, never a vendor SDK, so the role logic stays independent

{codejury-0.10.0 → codejury-0.10.2}/codejury/agents/debate.py

@@ -19,21 +19,24 @@ from codejury.agents.parsing import one_of, str_list, to_evidence, to_float
 from codejury.domain.artifact import CodeArtifact
 from codejury.domain.capability import Capability
 from codejury.domain.context import AnalysisContext
-from codejury.domain.observation import Concession, Finding, Observation
+from codejury.domain.observation import Concession, Finding, Observation, Severity
 from codejury.infrastructure.json_parse import extract_json_object
 from codejury.providers.base import Message, Provider
 
-_SEVERITY = {"CRITICAL", "HIGH", "MEDIUM", "LOW", "INFO"}
+from typing import get_args
+
+_SEVERITY = set(get_args(Severity))  # single source of truth: the Severity Literal
 
 _FINDING_SHAPE = (
     '{"capability": "id.sub", "title": "...", "severity": "HIGH", "cwe": "CWE-89", '
-    '"description": "...", "evidence": [{"file": "...", "line": 0, "code": "..."}], "confidence": 0.0}'
+    '"description": "...", "recommendation": "...", "matched_anti": ["id"], '
+    '"evidence": [{"file": "...", "line": 0, "code": "..."}], "confidence": 0.0}'
 )
 
 _DEEP_LENS = (
     "Look past surface patterns for the deepest flaw:\n"
-    "- Trust anchors: what does this code trust to authenticate or authorize -- a key, token, header, "
-    "signature, role, or caller -- and who controls that value? If the attacker supplies what is used to "
+    "- Trust anchors: what does this code trust to authenticate or authorize, such as a key, token, header, "
+    "signature, role, or caller, and who controls that value? If the attacker supplies what is used to "
     "verify them (e.g. their own public key, an unconfigured key that disables verification), passing the "
     "check proves nothing.\n"
     "- Order of operations: is an external, irreversible, or privileged action performed before the local "
@@ -98,7 +101,7 @@ class ChallengerAgent(_DebateAgent):
     def run(self, ctx: AnalysisContext) -> list[Observation]:
         parts = [
             "Challenge the findings below. For each one you believe is a false positive, write a rebuttal. "
-            "Add new_findings for any real issue that was missed -- especially a deeper flaw the finder "
+            "Add new_findings for any real issue that was missed, especially a deeper flaw the finder "
             "stopped short of.",
             _DEEP_LENS,
             _code(ctx.artifact),

{codejury-0.10.0 → codejury-0.10.2}/codejury/agents/mock.py

@@ -1,9 +1,8 @@
-"""MockAgent -- a minimal Agent for the dry-run and tests.
+"""MockAgent: a minimal Agent for the dry-run and tests.
 
 It really calls the provider (so the dry-run exercises the agent -> provider
 path), then emits one Verdict per in-scope capability, parking the model's reply
-in ``reasoning``. It does no real parsing or judgement; the Phase 3 VerifierAgent
-will.
+in ``reasoning``. It does no real parsing or judgement; ``VerifierAgent`` does.
 """
 
 from __future__ import annotations

codejury-0.10.2/codejury/agents/parsing.py

@@ -0,0 +1,45 @@
+"""Shared coercion from loosely-typed model JSON into domain values.
+
+Agents parse model output that may omit, mistype, or invent fields. These
+helpers coerce defensively: they never raise on bad input, they fall back.
+"""
+
+import math
+
+from codejury.domain.observation import Evidence
+
+
+def str_list(value: object) -> list[str]:
+    return [str(x) for x in value] if isinstance(value, list) else []
+
+
+def to_float(value: object, default: float) -> float:
+    # reject bool (it is an int subclass) and non-finite values (json.loads accepts
+    # NaN/Infinity); a NaN confidence would silently corrupt every downstream sort.
+    if isinstance(value, bool):
+        return default
+    try:
+        result = float(value)  # type: ignore[arg-type]
+    except (TypeError, ValueError):
+        return default
+    return result if math.isfinite(result) else default
+
+
+def one_of(value: object, allowed: set[str], default: str) -> str:
+    # `value in allowed` would raise TypeError on an unhashable model value
+    # (e.g. status -> [] or {}); guard so bad input falls back, never raises.
+    return value if isinstance(value, str) and value in allowed else default
+
+
+def to_evidence(items: object) -> list[Evidence]:
+    if not isinstance(items, list):
+        return []
+    out: list[Evidence] = []
+    for e in items:
+        if not isinstance(e, dict):
+            continue
+        line = e.get("line")
+        # a location needs a real 1-based line; reject 0, negatives, and bool (an int subclass)
+        valid_line = line if isinstance(line, int) and not isinstance(line, bool) and line >= 1 else None
+        out.append(Evidence(file=str(e.get("file", "")), line=valid_line, code=str(e.get("code", ""))))
+    return out

{codejury-0.10.0 → codejury-0.10.2}/codejury/agents/refuter.py

@@ -1,8 +1,8 @@
-"""RefuterAgent -- a skeptic that tries to dismiss flagged verdicts as false positives.
+"""RefuterAgent: a skeptic that tries to dismiss flagged verdicts as false positives.
 
 Used by the challenge orchestrator: the verifier flags issues, then the refuter
 gets the code plus the VULNERABLE verdicts (via ``ctx.history``) and argues which
-are false positives -- e.g. a value that is not actually attacker-controlled or a
+are false positives, e.g. a value that is not actually attacker-controlled or a
 sink that is not reachable. It returns a Concession per verdict it refutes.
 
 This is the cheap, focused alternative to a full debate: only flagged verdicts
@@ -53,7 +53,7 @@ class RefuterAgent(Agent):
             "is not attacker-controlled: a stored data field, or traced (here or in the call sites) to "
             "a trusted, config, or operator-supplied source. If its origin is not shown or could "
             "plausibly be external input, do NOT refute. For other issue types (hardcoded secrets, "
-            "weak crypto, ...), a literal value is often the vulnerability itself -- do NOT refute "
+            "weak crypto, ...), a literal value is often the vulnerability itself; do NOT refute "
             "those just because a value is constant.\n\n"
             "Respond with a single JSON object exactly like:\n" + _JSON_SHAPE
         )

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

@@ -1,9 +1,9 @@
-"""VerifierAgent -- check code against a capability's correct/anti patterns.
+"""VerifierAgent: check code against a capability's correct/anti patterns.
 
 It renders the capability into a prompt, calls the provider once per capability,
 and parses the JSON reply into Verdicts. It asks for one verdict per
 sub_capability including SECURE / NOT_PRESENT, so a report can say what was
-checked and what passed -- not only what failed.
+checked and what passed, not only what failed.
 
 Parsing is defensive: a missing or malformed reply yields no verdicts rather
 than raising, and unknown status values fall back to UNKNOWN.
@@ -15,11 +15,13 @@ from codejury.agents.base import Agent
 from codejury.agents.parsing import one_of, str_list, to_evidence, to_float
 from codejury.domain.capability import Capability
 from codejury.domain.context import AnalysisContext
-from codejury.domain.observation import Observation, Verdict
+from codejury.domain.observation import Observation, Verdict, VerdictStatus
 from codejury.infrastructure.json_parse import extract_json_object
 from codejury.providers.base import Message, Provider
 
-_VALID_STATUS = {"SECURE", "VULNERABLE", "PARTIAL", "NOT_PRESENT", "UNKNOWN"}
+from typing import get_args
+
+_VALID_STATUS = set(get_args(VerdictStatus))  # single source of truth: the VerdictStatus Literal
 
 _SYSTEM = (
     "You are a security verifier. You check code against a checklist of correct and "
@@ -73,7 +75,7 @@ def _render_capability(cap: Capability) -> str:
 def _build_prompt(path: str, content: str, cap: Capability, context: str = "") -> str:
     sub_names = ", ".join(cap.sub_capabilities) or "(none)"
     context_block = (
-        f"Related code (call sites / usages elsewhere -- for tracing where values come from, "
+        f"Related code (call sites / usages elsewhere, for tracing where values come from, "
         f"NOT under review):\n```\n{context}\n```\n\n"
         if context
         else ""
@@ -88,7 +90,7 @@ def _build_prompt(path: str, content: str, cap: Capability, context: str = "") -
         "For input-driven issues (injection, path traversal, SSRF), mark VULNERABLE only when "
         "untrusted/external input could plausibly reach the sink in the code shown. A constant, "
         "a stored data field, a value from trusted config, or a path or argument the operator "
-        "supplies (e.g. a CLI argument) is not attacker-controlled -- do not flag it.\n\n"
+        "supplies (e.g. a CLI argument) is not attacker-controlled; do not flag it.\n\n"
         "Respond with a single JSON object exactly like:\n" + _JSON_SHAPE
     )
 
@@ -108,8 +110,10 @@ def _anti_pattern_cwes(cap: Capability) -> dict[str, tuple[int, str]]:
 
 
 def _resolve_cwe(matched_anti: list[str], cwe_by_id: dict[str, tuple[int, str]]) -> str:
+    # the most severe matched anti-pattern's CWE; ties broken by CWE id so the result
+    # is fully determined by the inputs, not by dict/list ordering.
     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 ""
+    return max(matched, key=lambda rank_cwe: (rank_cwe[0], rank_cwe[1]))[1] if matched else ""
 
 
 def _parse_verdicts(text: str, cap: Capability) -> list[Verdict]:

{codejury-0.10.0 → codejury-0.10.2}/codejury/analysis/__init__.py

@@ -1,6 +1,6 @@
 """Static analysis for provenance (P1).
 
-The code-graph / data-flow engine that gives the verifier provenance -- whether a
+The code-graph / data-flow engine that gives the verifier provenance: whether a
 value reaching a sink is attacker-controlled, sanitized, or a trusted constant.
 This is the real fix for the taint precision floor that single-file LLM review
 cannot reach (see ROADMAP P1). Python / AST based to start.

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

@@ -8,7 +8,7 @@ and literals a value derives from.
 The analysis is deliberately conservative and flow-insensitive: a name assigned
 more than once contributes the union of all its right-hand sides, so a possible
 source is never dropped (recall over precision). A value built only from literals
-is reported as ``is_constant`` -- the signal that distinguishes, for example,
+is reported as ``is_constant``, the signal that distinguishes, for example,
 SQL concatenated from constants (safe) from SQL concatenated from a parameter.
 
 This module finds where a value comes from; it does not decide what is a source
@@ -43,7 +43,7 @@ class Origin:
 
     @property
     def is_constant(self) -> bool:
-        """True when the value is built only from literals -- no param, call, attr,
+        """True when the value is built only from literals: no param, call, attr,
         free name, or unmodelled expression contributes."""
         return not (self.params or self.calls or self.attrs or self.globals_ or self.unknown)
 
@@ -65,7 +65,7 @@ def parse_function(source: str, name: str) -> ast.FunctionDef | ast.AsyncFunctio
 
 
 def find_calls(scope: ast.AST, callee: str) -> list[ast.Call]:
-    """Every call within ``scope`` whose function is named ``callee`` -- matching a
+    """Every call within ``scope`` whose function is named ``callee``, matching a
     bare name (``open``) or the final attribute (``execute`` in ``cur.execute``)."""
     return [node for node in ast.walk(scope) if isinstance(node, ast.Call) and _call_name(node) == callee]
 
@@ -97,7 +97,7 @@ def trace_value(func: ast.FunctionDef | ast.AsyncFunctionDef, expr: ast.AST) ->
         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
+        on_cycle=Origin,  # assignment cycle, no new information
     )
 
 
@@ -182,7 +182,7 @@ def reduce_value(
     if isinstance(expr, (ast.List, ast.Tuple, ast.Set)):
         return combine([recurse(e) for e in expr.elts])
     if isinstance(expr, ast.Name):
-        if expr.id in seen:  # assignment cycle -- stop
+        if expr.id in seen:  # assignment cycle, stop
             return on_cycle()
         if expr.id in params:
             return on_param(expr.id)

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

@@ -6,7 +6,7 @@ sanitizer makes it SANITIZED (taint stops), a propagator carries taint through t
 the result, and a trusted origin or a literal is clean.
 
 The point is to let a later layer (P1-04) downgrade a taint finding only when the
-value is *provably* not attacker-controlled -- ``classification in SAFE`` -- so
+value is *provably* not attacker-controlled (``classification in SAFE``), so
 recall is preserved: anything uncertain is UNKNOWN or PARAM, never quietly safe.
 
 Two documented precision leans: a bare module-global name (e.g. ``STATIC_DIR``)
@@ -42,7 +42,7 @@ from codejury.resources import TAINT_FILE
 
 class Taint(str, Enum):
     EXTERNAL = "external"    # derives from an attacker source, not sanitized
-    UNKNOWN = "unknown"      # an unknown call / access -- cannot prove either way
+    UNKNOWN = "unknown"      # an unknown call / access; cannot prove either way
     PARAM = "param"          # depends on a parameter; resolve at the call site (cross-file)
     SANITIZED = "sanitized"  # had an external component, but a sanitizer neutralized it
     TRUSTED = "trusted"      # operator/config/global origin
@@ -131,14 +131,14 @@ def taint_of(
                 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
+            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
+            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
@@ -150,7 +150,7 @@ def taint_of(
         combine=_combine,
         leaf=leaf,
         on_param=on_param,
-        on_global=lambda n: Taint.TRUSTED,    # free module global / builtin -- conventionally a constant
+        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
     )
@@ -261,7 +261,7 @@ 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. A safe sink that consumes
-    tainted data (e.g. ``json.loads(request.data)``) contributes SANITIZED -- the
+    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

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

@@ -1,4 +1,4 @@
-"""Assembly -- build an orchestration from a strategy name and run it over a source.
+"""Assembly: build an orchestration from a strategy name and run it over a source.
 
 Shared by the CLI and the task layer so the "which agents + which orchestrator"
 mapping and the per-artifact run loop live in one place.
@@ -88,7 +88,7 @@ def build_orchestration(
 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__
+    return type(getattr(provider, "inner", provider)).__name__
 
 
 def orchestration_descriptor(provider: Provider, strategy: str, model: str, max_tokens: int) -> str:

{codejury-0.10.0 → codejury-0.10.2}/codejury/baseline.py

@@ -1,27 +1,25 @@
-"""Diff baseline -- report only findings new since a stored baseline report.
+"""Diff baseline: report only findings new since a stored baseline report.
 
-The keystone for PR-time noise control: run against a saved baseline report (the
-target branch's findings) and keep only the problem observations whose
+The keystone for PR-time noise control: run against a saved baseline report, the
+target branch's findings, and keep only the problem observations whose
 fingerprint is absent from the baseline, so a review shows what this change
-introduced -- not the codebase's pre-existing findings. Paired with --fail-on,
+introduced rather than the codebase's pre-existing findings. Paired with --fail-on,
 CI then gates on new issues only.
 
-The fingerprint is line-number-tolerant (lines shift between versions): it keys
+The fingerprint is line-number-tolerant because lines shift between versions: it keys
 on the capability, the kind/severity/status, the matched patterns, and the
-normalized evidence snippet -- never the line number. Only problem observations
-(Findings, VULNERABLE/PARTIAL Verdicts) are compared and dropped; SECURE /
-NOT_PRESENT verdicts and concessions are always kept.
+normalized evidence snippet, never the line number. Only problem observations,
+namely Findings and VULNERABLE/PARTIAL Verdicts, are compared and dropped; SECURE
+and NOT_PRESENT verdicts and concessions are always kept.
 """
 
 from __future__ import annotations
 
-from codejury.domain.observation import Concession, Finding, Observation, Verdict
+from codejury.domain.observation import Concession, Finding, Observation, Verdict, is_problem
 from codejury.domain.result import AnalysisResult
 
 Results = list[tuple[str, AnalysisResult]]
 
-_PROBLEM_STATUSES = ("VULNERABLE", "PARTIAL")
-
 
 def finding_key(o: Observation) -> tuple:
     """A location-tolerant fingerprint for matching a finding across versions."""
@@ -39,13 +37,13 @@ def filter_new(results: Results, baseline: Results) -> tuple[Results, int]:
 
     Returns (filtered_results, dropped_count). Non-problem observations are kept.
     """
-    seen = {finding_key(o) for _, r in baseline for o in r.observations if _is_problem(o)}
+    seen = {finding_key(o) for _, r in baseline for o in r.observations if is_problem(o)}
     filtered: Results = []
     dropped = 0
     for path, result in results:
         kept: list[Observation] = []
         for o in result.observations:
-            if _is_problem(o) and finding_key(o) in seen:
+            if is_problem(o) and finding_key(o) in seen:
                 dropped += 1
             else:
                 kept.append(o)
@@ -53,10 +51,8 @@ def filter_new(results: Results, baseline: Results) -> tuple[Results, int]:
     return filtered, dropped
 
 
-def _is_problem(o: Observation) -> bool:
-    return isinstance(o, Finding) or (isinstance(o, Verdict) and o.status in _PROBLEM_STATUSES)
-
-
 def _evidence_sig(o: Observation) -> str:
+    # fingerprints only the first evidence snippet, enough to distinguish findings
+    # in practice; two findings differing only in a later snippet would collide.
     evidence = getattr(o, "evidence", [])
     return " ".join(evidence[0].code.split()) if evidence and evidence[0].code else ""

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

@@ -280,6 +280,7 @@ def main(argv: list[str] | None = None) -> int:
     scan_p.add_argument("--no-suppress", action="store_true", help="disable the known-noise suppression filter")
     scan_p.add_argument("--no-cache", action="store_true", help="bypass the verdict cache (always re-query the model)")
     scan_p.add_argument("--baseline", default=None, help="a prior JSON report; report only findings new since it")
+    scan_p.add_argument("--retries", type=int, default=0, help="provider retry attempts on failure")
     scan_p.add_argument("--fail-on", choices=_FAIL_ON, default=None, dest="fail_on", help="exit 1 if a finding at/above this severity is found")
 
     run_p = sub.add_parser("run", help="run a named task preset against a unified diff")
@@ -301,9 +302,19 @@ def main(argv: list[str] | None = None) -> int:
     eval_p.add_argument("--model", default=DEFAULT_MODEL)
     eval_p.add_argument("--api-base", default=DEFAULT_API_BASE, help="provider base URL (env: CODEJURY_API_BASE)")
     eval_p.add_argument("--api-key", default=DEFAULT_API_KEY, help="provider API key (env: CODEJURY_API_KEY)")
+    eval_p.add_argument("--retries", type=int, default=0, help="provider retry attempts on failure")
 
     args = parser.parse_args(argv)
+    try:
+        return _dispatch(args, parser)
+    except Exception as exc:
+        # expected failures (missing diff file, provider auth, malformed input) become
+        # one stderr line, not a traceback. eval's own message is preserved by command name.
+        print(f"{args.command or 'codejury'} failed: {exc}", file=sys.stderr)
+        return 1
 
+
+def _dispatch(args, parser) -> int:
     if args.command == "audit":
         results = audit(
             _read_diff(args.diff),
@@ -326,12 +337,15 @@ def main(argv: list[str] | None = None) -> int:
         capabilities = load_capabilities(args.capabilities)
         if args.only:
             wanted = {x.strip() for x in args.only.split(",")}
+            unknown = wanted - {c.id for c in capabilities}
+            if unknown:
+                print(f"warning: --only names unknown capability id(s): {', '.join(sorted(unknown))}", file=sys.stderr)
             capabilities = [c for c in capabilities if c.id in wanted]
         extensions = tuple(e if e.startswith(".") else "." + e for e in args.ext.split(","))
         results = scan(
             args.directory,
             capabilities,
-            provider=make_provider(args.provider, api_key=args.api_key, api_base=args.api_base),
+            provider=make_provider(args.provider, api_key=args.api_key, api_base=args.api_base, retries=args.retries),
             model=args.model,
             max_tokens=args.max_tokens,
             strategy=args.orchestrator,
@@ -359,19 +373,13 @@ def main(argv: list[str] | None = None) -> int:
         return _gate_exit(results, args.fail_on)
 
     if args.command == "eval":
-        try:
-            report = evaluate(
-                load_cases(args.dataset, split=args.split),
-                load_capabilities(args.capabilities),
-                provider=make_provider(args.provider, api_key=args.api_key, api_base=args.api_base),
-                model=args.model,
-                strategy=args.orchestrator,
-            )
-        except Exception as exc:
-            # e.g. a missing API key surfaces as a provider auth error -- report it
-            # as one line, not a traceback (audit gets this via the orchestrator).
-            print(f"eval failed: {exc}")
-            return 1
+        report = evaluate(
+            load_cases(args.dataset, split=args.split),
+            load_capabilities(args.capabilities),
+            provider=make_provider(args.provider, api_key=args.api_key, api_base=args.api_base, retries=args.retries),
+            model=args.model,
+            strategy=args.orchestrator,
+        )
         print(json.dumps(report.to_dict(), indent=2) if args.fmt == "json" else _render_eval(report))
         return 0