codejury 0.18.0__tar.gz → 0.19.0__tar.gz

{codejury-0.18.0 → codejury-0.19.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codejury
-Version: 0.18.0
+Version: 0.19.0
 Summary: AI code security review: an adversarial diff-audit engine and an agent-driven whole-repo review methodology, with security knowledge as rich rules
 Author: AISecLabs
 License-Expression: MIT

codejury-0.19.0/codejury/data/detection.yaml

@@ -0,0 +1,17 @@
+# File and path classification, across ecosystems: what the engine treats as a
+# source file, a dependency manifest, a noise directory, or test code. Kept here
+# so the implementation enumerates no language itself, adding a language is a
+# data edit. This is distinct from a guide's stack detection, which decides which
+# language, framework, or protocol applies.
+
+skip_dirs: [".git", ".venv", "venv", "node_modules", "__pycache__", ".mypy_cache", ".pytest_cache"]
+
+source_extensions: [".py", ".js", ".ts", ".tsx", ".jsx", ".mjs", ".go", ".rb", ".java", ".kt", ".php", ".cs", ".scala", ".rs"]
+
+config_extensions: [".yaml", ".yml", ".toml", ".ini", ".cfg", ".conf", ".env"]
+
+manifests: ["requirements.txt", "requirements-dev.txt", "pyproject.toml", "setup.py", "Pipfile", "package.json", "go.mod", "Gemfile", "pom.xml", "build.gradle", "Cargo.toml", "composer.json"]
+
+test_dirs: ["test", "tests", "__tests__", "__mocks__", "mocks", "fixtures", "testdata", "e2e", "spec", "specs"]
+
+test_name_patterns: ["test_*", "*_test.*", "*.test.*", "*.spec.*"]

codejury-0.19.0/codejury/data/frameworks/go/echo.md

@@ -0,0 +1,31 @@
+---
+id: echo
+title: Echo
+kind: framework
+language: go
+detect:
+  manifest: ["labstack/echo"]
+  imports: ["github.com/labstack/echo"]
+entrypoint_files: ["*main.go", "*/handlers/*.go", "*/handler/*.go", "*/api/*.go", "*/routes/*.go", "*/controllers/*.go"]
+entrypoint_markers: ["echo.New(", "echo.Context", "e.GET", "e.POST", ".GET(", ".POST(", ".Group(", "c.Param", "c.QueryParam", "c.Bind"]
+logic_layers: ["*/service/*.go", "*/services/*.go", "*/usecase/*.go", "*/repository/*.go", "*/repo/*.go", "*/store/*.go", "*/dao/*.go", "*/model/*.go"]
+---
+# Echo Review Notes
+
+## Entrypoints
+- Handlers have the signature `func(c echo.Context) error`, registered with
+  `e.GET`, `.POST`, and grouped under `e.Group`. Input comes from `c.Param`,
+  `c.QueryParam`, `c.FormValue`, `c.Request().Header`, and `c.Bind` into a struct.
+
+## Authorization / IDOR
+- Auth is middleware, applied globally, on a `Group`, or per route. The flaw to
+  hunt is a route registered outside the authenticated group, inheriting no
+  check. Compare grouped routes against routes on the bare instance.
+- IDOR: a record loaded by `c.Param("id")` with no owner or tenant scope.
+
+## Common Sinks / Gotchas
+- SQL: `fmt.Sprintf` into `db.Query` or `db.Exec`, instead of placeholders.
+- Command: `exec.Command` built from input.
+- Path: `c.File` or `c.Attachment` and `filepath.Join` on a path from input.
+- `c.Bind` into a struct with privileged fields is mass assignment.
+- A returned `error` that the caller drops can hide a failed auth or validation.

codejury-0.19.0/codejury/data/frameworks/go/gin.md

@@ -0,0 +1,34 @@
+---
+id: gin
+title: Gin
+kind: framework
+language: go
+detect:
+  manifest: ["gin-gonic/gin"]
+  imports: ["github.com/gin-gonic/gin"]
+entrypoint_files: ["*main.go", "*/handlers/*.go", "*/handler/*.go", "*/api/*.go", "*/routes/*.go", "*/controllers/*.go"]
+entrypoint_markers: ["gin.Default(", "gin.New(", "*gin.Context", "router.GET", "router.POST", ".GET(", ".POST(", ".Group(", "c.Param", "c.Query", "c.ShouldBind"]
+logic_layers: ["*/service/*.go", "*/services/*.go", "*/usecase/*.go", "*/repository/*.go", "*/repo/*.go", "*/store/*.go", "*/dao/*.go", "*/model/*.go"]
+---
+# Gin Review Notes
+
+## Entrypoints
+- Handlers have the signature `func(c *gin.Context)`, registered with
+  `router.GET`, `.POST`, and grouped under `router.Group`. Input comes from
+  `c.Param`, `c.Query`, `c.PostForm`, `c.GetHeader`, and `c.ShouldBindJSON` or
+  `c.Bind` into a struct.
+
+## Authorization / IDOR
+- Auth is middleware, applied globally, on a `Group`, or per route. The classic
+  flaw is a route registered outside the authenticated group, so it inherits no
+  check. Compare a group's routes against the routes registered on the bare
+  engine.
+- IDOR: a record loaded by `c.Param("id")` with no owner or tenant scope.
+
+## Common Sinks / Gotchas
+- SQL: `fmt.Sprintf` into `db.Query` or `db.Exec`, instead of placeholders.
+- Command: `exec.Command` built from input.
+- Path: `c.File` or `filepath.Join` on a path from input, the traversal sink.
+- `c.ShouldBindJSON` into a struct with privileged fields is mass assignment.
+- A handler that ignores the error from a bind or an auth call proceeds as if it
+  passed.

codejury-0.19.0/codejury/data/frameworks/javascript/express.md

@@ -0,0 +1,36 @@
+---
+id: express
+title: Express
+kind: framework
+language: javascript
+detect:
+  manifest: ["express"]
+  imports: ["require('express')", "require(\"express\")", "from 'express'"]
+entrypoint_files: ["*app.js", "*server.js", "*app.ts", "*server.ts", "*/routes/*.js", "*/routes/*.ts", "*/controllers/*.js", "*/controllers/*.ts", "*router*.js", "*router*.ts"]
+entrypoint_markers: ["express()", "app.get(", "app.post(", "app.use(", "router.get(", "router.post(", ".get(", ".post(", "req.params", "req.query", "req.body"]
+logic_layers: ["*/services/*.js", "*/services/*.ts", "*/models/*.js", "*/models/*.ts", "*/repositories/*.js", "*/repositories/*.ts", "*/dao/*.js", "*/dao/*.ts"]
+---
+# Express Review Notes
+
+Works the same in JavaScript and TypeScript. See the JavaScript guide for the
+runtime sinks.
+
+## Entrypoints
+- Routes are `app.get` / `app.post` / `router.*`, and a `Router` mounted with
+  `app.use("/prefix", router)`. The handler is `(req, res, next)`. Input is
+  `req.params`, `req.query`, `req.body`, `req.headers`, and `req.cookies`.
+
+## Authorization / IDOR
+- Auth is middleware, passed to `app.use` or per route. The flaw to hunt is a
+  route mounted before the auth middleware, or one that omits the middleware its
+  siblings have, so order and placement matter.
+- IDOR: a record loaded by `req.params.id` with no owner or tenant scope.
+
+## Common Sinks / Gotchas
+- SQL and NoSQL: a query built by string concatenation, or a Mongo filter built
+  straight from `req.body`, the operator-injection sink.
+- Command: `child_process.exec` from input. Code: `eval` from input.
+- Path: `res.sendFile` or `path.join` on a path from input, the traversal sink.
+- Open redirect via `res.redirect(req.query...)`, and prototype pollution from a
+  body merge.
+- A body spread whole into a model or an ORM create is mass assignment.

codejury-0.19.0/codejury/data/frameworks/javascript/nestjs.md

@@ -0,0 +1,36 @@
+---
+id: nestjs
+title: NestJS
+kind: framework
+language: javascript
+detect:
+  manifest: ["@nestjs/core", "@nestjs/common"]
+  imports: ["@nestjs/common", "@nestjs/core"]
+entrypoint_files: ["*.controller.ts", "*.controller.js", "*/controllers/*.ts", "*.resolver.ts", "*.gateway.ts"]
+entrypoint_markers: ["@Controller(", "@Get(", "@Post(", "@Put(", "@Delete(", "@Body(", "@Param(", "@Query(", "@UseGuards("]
+logic_layers: ["*.service.ts", "*.service.js", "*/services/*.ts", "*.repository.ts", "*/repositories/*.ts", "*.entity.ts", "*/dao/*.ts"]
+---
+# NestJS Review Notes
+
+Usually TypeScript on Node. See the JavaScript and TypeScript guides for the
+runtime sinks and for why types do not sanitize input.
+
+## Entrypoints
+- A `@Controller` class with `@Get` / `@Post` methods. Input binds through
+  `@Param`, `@Query`, `@Body`, and `@Headers`. GraphQL resolvers and WebSocket
+  gateways are entrypoints too.
+
+## Authorization / IDOR
+- Access control is a guard applied with `@UseGuards`, at the controller or the
+  method, plus role decorators. The flaw to hunt is a route or controller missing
+  the guard its siblings declare, and a guard that authenticates but does not
+  authorize the specific resource.
+- IDOR: a handler that loads by `@Param("id")` with no owner or tenant check.
+
+## Common Sinks / Gotchas
+- Mass assignment: a `@Body` DTO with no `ValidationPipe` and `whitelist: true`
+  binds any field the client sends. Confirm the pipe is global or applied.
+- SQL: a TypeORM or Prisma raw query built from input.
+- SSRF: a server-side `fetch` or `axios` to a URL from input.
+- A custom guard that returns true on an unhandled path, or reads the user from a
+  header the client controls.

{codejury-0.18.0 → codejury-0.19.0}/codejury/data/frameworks/python/django.md

@@ -9,6 +9,7 @@ detect:
   imports: ["from django", "import django"]
 entrypoint_files: ["*urls.py", "*views.py", "*viewsets.py", "*/views/*.py", "*serializers.py", "*api.py", "*consumers.py"]
 entrypoint_markers: ["APIView", "ViewSet", "@api_view", "@action", "router.register", "path(", "re_path(", "as_view("]
+logic_layers: ["*/controllers/*.py", "*controllers.py", "*/managers/*.py", "*managers.py", "*/dao/*.py", "*dao.py", "*/services/*.py", "*services.py", "*/models/*.py", "*models.py"]
 ---
 # Django Review Notes
 

codejury-0.19.0/codejury/data/frameworks/python/fastapi.md

@@ -0,0 +1,37 @@
+---
+id: fastapi
+title: FastAPI
+kind: framework
+language: python
+detect:
+  manifest: ["fastapi"]
+  imports: ["from fastapi", "import fastapi"]
+entrypoint_files: ["*main.py", "*/routers/*.py", "*/api/*.py", "*api.py", "*routes.py", "*/endpoints/*.py"]
+entrypoint_markers: ["FastAPI(", "APIRouter(", "@app.get", "@app.post", "@router.get", "@router.post", "Depends("]
+logic_layers: ["*/services/*.py", "*services.py", "*/models/*.py", "*models.py", "*/repositories/*.py", "*/crud/*.py", "*/dao/*.py"]
+---
+# FastAPI Review Notes
+
+## Entrypoints
+- Path operations decorated with `@app.get` / `@app.post` or `@router.*` on an
+  `APIRouter`. Inputs arrive as path and query parameters, and as a request body
+  validated by a Pydantic model.
+- A Pydantic model bounds the body's shape, but an over-wide model still binds
+  privileged fields, the mass-assignment shape.
+
+## Authorization / IDOR
+- Auth and access control run through `Depends`, for example a dependency that
+  resolves the current user or checks a scope. Note an endpoint that omits the
+  dependency its siblings use, or a dependency that authenticates but does not
+  authorize the specific resource.
+- IDOR: an endpoint that loads a record by an id parameter with no owner or tenant
+  check.
+
+## Common Sinks / Gotchas
+- SQL: a raw query or an ORM `text()` built from a parameter.
+- SSRF: `httpx` or `requests` to a URL from input, common in webhook and fetch
+  endpoints.
+- Path: `FileResponse` on a path from input.
+- `CORSMiddleware` with `allow_origins=["*"]` together with credentials, and an
+  OAuth2 bearer dependency that decodes a token without verifying signature,
+  audience, and expiry.

codejury-0.19.0/codejury/data/frameworks/python/flask.md

@@ -0,0 +1,37 @@
+---
+id: flask
+title: Flask
+kind: framework
+language: python
+detect:
+  manifest: ["flask"]
+  imports: ["from flask", "import flask"]
+entrypoint_files: ["*app.py", "*views.py", "*routes.py", "*/views/*.py", "*/blueprints/*.py", "*api.py"]
+entrypoint_markers: ["@app.route", ".route(", "Blueprint(", "add_url_rule(", "MethodView", "@app.before_request"]
+logic_layers: ["*/services/*.py", "*services.py", "*/models/*.py", "*models.py", "*/repositories/*.py", "*/dao/*.py"]
+---
+# Flask Review Notes
+
+## Entrypoints
+- Routes are functions decorated with `@app.route` or `@bp.route`, or registered
+  with `add_url_rule`. Blueprints mount a group under a URL prefix. Class views
+  subclass `MethodView`.
+- Read input from `request.args`, `request.form`, `request.values`,
+  `request.json`, `request.files`, `request.headers`, and `request.cookies`, all
+  attacker-controlled.
+
+## Authorization / IDOR
+- Auth is enforced by a `@login_required` style decorator, a `before_request`
+  hook, or an explicit check in the view. Note where it is and where a route
+  lacks it.
+- IDOR: a model fetched by an id from the request with no owner or tenant scope,
+  then returned.
+
+## Common Sinks / Gotchas
+- SSTI: `render_template_string` on input, or `Markup` and `|safe` on unescaped
+  input.
+- SQL: raw `cursor.execute` or an ORM `text()` built from input.
+- Path: `send_file` or `send_from_directory` with a path from input, the traversal
+  sink.
+- A hardcoded `SECRET_KEY`, `debug=True` in production, and an open redirect via
+  `redirect(request.args[...])`.

codejury-0.19.0/codejury/data/languages/go.md

@@ -0,0 +1,35 @@
+---
+id: go
+title: Go
+kind: language
+detect:
+  files: ["*.go", "go.mod"]
+entrypoint_files: ["*main.go", "*/handlers/*.go", "*/handler/*.go", "*/api/*.go", "*/routes/*.go"]
+entrypoint_markers: ["http.HandleFunc", "http.ListenAndServe", "ServeMux", "http.Handler", "func(w http.ResponseWriter"]
+logic_layers: ["*/service/*.go", "*/services/*.go", "*/usecase/*.go", "*/repository/*.go", "*/repo/*.go", "*/store/*.go", "*/dao/*.go", "*/model/*.go", "*/models/*.go"]
+---
+# Go Review Notes
+
+Where untrusted input enters beyond web routes, which the framework guides cover.
+The standard `net/http` server is itself an entrypoint: a handler that takes an
+`http.ResponseWriter` and an `*http.Request`, registered with `http.HandleFunc`
+or a `ServeMux`. Read the request through `r.URL.Query`, `r.FormValue`, `r.PathValue`,
+`r.Header`, and the decoded body, all attacker-controlled.
+
+## Common Sinks
+- SQL: a query built with `fmt.Sprintf` or string concatenation passed to
+  `db.Query` or `db.Exec`. Use placeholders, never build SQL from input.
+- Command: `exec.Command` with a shell or with arguments built from input,
+  `os/exec` reaching `sh -c`.
+- Path: `filepath.Join` or `os.Open` on a path from input with no `filepath.Clean`
+  and containment check, the traversal sink.
+- SSRF: `http.Get`, `http.NewRequest`, or a client `Do` on a URL from input.
+- Deserialization and templates: `encoding/gob`, `text/template` rendering input,
+  and `html/template` used with the wrong escaping context.
+
+## Gotchas
+- Errors ignored with `_` can skip a security check whose failure is never seen.
+- A type assertion or `interface{}` body decoded with `json.Unmarshal` into a
+  wide struct is mass assignment if privileged fields are bound.
+- Goroutines and shared state without a lock are a race, relevant to one-time
+  tokens and balances.

codejury-0.19.0/codejury/data/languages/javascript.md

@@ -0,0 +1,34 @@
+---
+id: javascript
+title: JavaScript
+kind: language
+detect:
+  files: ["*.js", "*.mjs", "*.cjs", "*.jsx"]
+entrypoint_files: ["*server.js", "*app.js", "*index.js", "*/routes/*.js", "*/handlers/*.js", "*/api/*.js"]
+entrypoint_markers: ["http.createServer", "createServer(", "require('http')", "addEventListener('fetch'", "exports.handler"]
+logic_layers: ["*/services/*.js", "*/service/*.js", "*/models/*.js", "*/repositories/*.js", "*/dao/*.js", "*service*.js", "*model*.js"]
+---
+# JavaScript Review Notes
+
+Node is the usual runtime. Where untrusted input enters beyond web routes, which
+the framework guides cover. A plain `http.createServer` callback, a serverless
+`exports.handler`, and a `fetch` event listener are entrypoints too. Read the
+request body, query, params, headers, and cookies as attacker-controlled.
+
+## Common Sinks
+- Command: `child_process.exec`, `execSync`, or `spawn` with a shell, built from
+  input.
+- Code: `eval`, `new Function`, `vm.runInContext` on input.
+- SQL and NoSQL: a query built by string concatenation or template literal, and a
+  Mongo query that takes a raw object from the body, the operator-injection sink.
+- Path: `fs.readFile`, `path.join`, or `res.sendFile` on a path from input with no
+  containment check.
+- SSRF: `fetch`, `axios`, or `http.request` on a URL from input.
+- Prototype pollution: a recursive merge or `lodash.merge` of a request body into
+  an object, reaching `__proto__`.
+
+## Gotchas
+- A missing `await` on an async auth check lets the handler proceed before it
+  resolves.
+- A regex from input, or a catastrophic backtracking regex on input, is a ReDoS.
+- `JSON.parse` of input into a wide model and assigning it whole is mass assignment.

codejury-0.19.0/codejury/data/languages/typescript.md

@@ -0,0 +1,28 @@
+---
+id: typescript
+title: TypeScript
+kind: language
+detect:
+  files: ["*.ts", "*.tsx"]
+entrypoint_files: ["*server.ts", "*app.ts", "*index.ts", "*/routes/*.ts", "*/handlers/*.ts", "*/api/*.ts"]
+entrypoint_markers: ["http.createServer", "createServer(", "addEventListener('fetch'", "export const handler", "export async function handler"]
+logic_layers: ["*/services/*.ts", "*/service/*.ts", "*/models/*.ts", "*/repositories/*.ts", "*/dao/*.ts", "*service*.ts", "*model*.ts"]
+---
+# TypeScript Review Notes
+
+TypeScript runs as JavaScript on Node, so the JavaScript sinks and gotchas all
+apply, read the JavaScript guide. The Node frameworks are shared, so an Express
+or Nest service in TypeScript uses the same framework guides under
+`frameworks/javascript`.
+
+## What Types Do Not Protect
+- Types are erased at runtime. A value typed as `string` is still attacker
+  input, so type annotations do not sanitize a query, a path, or a command.
+- A DTO typed in the code does not constrain the request body unless a runtime
+  validator such as class-validator or zod actually enforces it, so an
+  unvalidated body is still mass assignment.
+- An `as` cast or `any` hides an untrusted value behind a safe-looking type.
+- `JSON.parse` returns `any`, so a parsed body carries no real guarantees.
+
+Beyond that, hunt the same sinks as JavaScript: command, code, SQL and NoSQL,
+path traversal, SSRF, and prototype pollution.

{codejury-0.18.0 → codejury-0.19.0}/codejury/data/methodologies/repo-review.md

@@ -29,6 +29,9 @@ Workspace: `<workspace>/<project>/`, created for you, holding `entrypoints/`,
 4. Read the relevant vulnerability files under the shipped `vulnerabilities/` for
    the target's stack such as sql-injection, idor, ssrf, jwt-validation, or
    insecure-deserialization.
+5. Read `analysis/_trace_targets.md`, the seeded downstream logic-layer files such
+   as managers and dao to trace into, and `analysis/_rounds.md`, the round ledger
+   you must keep. See "Trace Attack Paths" and "Completeness Gate".
 
 ## Map the Attack Surface
 
@@ -94,8 +97,11 @@ Then hunt three shapes:
 A whole-repo review earns its keep by reasoning *across files*: a flaw is usually
 a source in one file reaching a dangerous sink in another, past a control defined
 in a third, for example a route that trusts a helper which skips signature checks, or an id that
-reaches a query with no ownership check. For each promising source, trace the
-path and record it in `analysis/`:
+reaches a query with no ownership check. The flaw usually lives below the
+entrypoint, in a manager, a controller, a dao, or a service, not in the view. The
+seeded `analysis/_trace_targets.md` lists those downstream logic-layer files. For
+each promising source, follow the calls out of the entrypoint into those layers
+to the real sink, and record the path in `analysis/`:
 
 - **Source**: the entrypoint and the attacker-controlled value.
 - **Sink**: the dangerous operation it reaches such as a query, shell, file path, fetch,
@@ -106,19 +112,45 @@ path and record it in `analysis/`:
 
 The vulnerability is a path with a reachable sink and no adequate control. Record
 the system's trust boundaries and auth/authz model in `analysis/` once, so every
-trace can refer to it instead of restating it.
+trace can refer to it instead of restating it. An entrypoint is not done until its
+path is traced through the downstream layers to a sink or cleared, since stopping
+at the view is what hides the deep flaw, for example the missing lock in a dao or
+the skipped expiry check in a manager.
+
+## Controls That Live in a Library
+
+An entrypoint's security control is often not in the first-party code at all: the
+authentication, the signature or replay check, the permission test is implemented
+in a library the endpoint calls. You cannot judge whether the endpoint is
+exploitable from the first-party code alone, because the control that would stop
+the attack lives in the library.
+
+So when a traced path relies on a control a library provides, follow into that
+library's relevant function and verify it actually enforces the control, for
+example that a signature check also binds a nonce or a timestamp window, or that
+an auth helper truly validates the caller. Read the specific function the path
+depends on, not the whole library, and read it where it is installed or vendored.
+
+This is about this app's exposure, so it applies to any library, internal or
+third-party. It is not auditing the library for its own bugs, which belongs to
+that library's own review. It is confirming that the control your endpoint relies
+on holds here.
 
 ## Scope
 
 Report only HIGH / CRITICAL, exploitable, high-confidence issues. **Do not report**
 regardless of severity, dependency CVEs, style or best-practice notes,
 speculative issues you cannot tie to a concrete exploit, and risks that only
-matter if production config is leaked.
+matter if production config is leaked. A control that a library fails to enforce
+for a reachable first-party entrypoint is not a dependency CVE, it is this app's
+exploitable exposure, so it is in scope. See "Controls That Live in a Library".
 
 ## Recording an Issue
 
-Write one `issues/<name>.md` per confirmed issue. Do not write an issue you cannot
-confirm with high confidence. Each must have:
+Write one `issues/<name>.md` per issue, and save its PoC as a real runnable file
+`issues/poc_<name>.<ext>`, a script or an `.http` file, not a sketch in prose. If
+you cannot write a concrete runnable PoC, the finding is most likely a false
+positive, so do not report it. Each issue file must have:
 
 ```markdown
 # <title>
@@ -126,6 +158,7 @@ confirm with high confidence. Each must have:
 - Risk: HIGH | CRITICAL
 - Type: IDOR | auth bypass | signature flaw | business logic | ...
 - Source: `<METHOD> <path>` or the non-HTTP entrypoint (queue, deserializer, ...)
+- Verification: reproduced | blocked, needs <what> | not run
 
 ## Analysis
 (cite exact file paths and line numbers)
@@ -134,22 +167,29 @@ confirm with high confidence. Each must have:
 (end-to-end, actionable steps)
 
 ## PoC
-(a curl command or script that actually triggers it)
+(the path to `issues/poc_<name>.<ext>` and how to run it)
 
 ## Verification
-(result of actually running the PoC in a sandbox / dev environment)
+(the actual output of running the PoC, or the exact blocker)
 
 ## Fix
 ```
 
-## PoC Verification, Human in the Loop
+## PoC Verification, the False-Positive Gate
 
-Confirm each issue by running the PoC against a sandbox / dev environment. When
-you need something only the operator has, stop and ask:
+A finding is a hypothesis until a PoC proves it. The tool, and you, can be
+confident and still wrong, so the PoC is what separates a real vulnerability from
+a plausible misread. Confirm each issue by running its PoC against a sandbox or
+dev environment, and gate reporting on the result:
 
-- an auth cookie or token,
-- an MFA step,
-- specific test data or an account.
+- **Reproduced**: the PoC ran and triggered the issue. Only these are reported as
+  confirmed HIGH / CRITICAL.
+- **Blocked**: the PoC is written and correct but you need something only the
+  operator has, so stop and ask, for an auth cookie or token, an MFA step, or
+  specific test data or an account. Report these separately as suspected and
+  needing verification, with the exact blocker, never mixed into the confirmed
+  set.
+- **Not run with no concrete PoC**: do not report. It is a guess.
 
 Never run a PoC against production, and never use real credentials or perform a
 destructive action without the operator's explicit go-ahead.
@@ -158,13 +198,32 @@ destructive action without the operator's explicit go-ahead.
 
 Each round, read the workspace history first and do not repeat finished work.
 Process leftover TODOs, otherwise pick an unreviewed ❌ or to-deepen ⚠️ source
-from the inventory. One round rarely finds the deep cross-file and stateful bugs,
-so keep going until two consecutive rounds surface nothing new, then report the
-review complete. The hard classes such as authorization, replay, and broken
-business state usually appear only after several rounds.
+from the inventory, trace it through the downstream layers, and log the round in
+`analysis/_rounds.md`. One round rarely finds the deep cross-file and stateful
+bugs. The hard classes such as authorization, replay, and broken business state
+usually appear only after several rounds, so keep going.
+
+## Completeness Gate
+
+Do not report the review complete until all of the following hold. A short run
+with most entrypoints still ❌ is an incomplete review, not a clean one, and
+reporting it as clean is the failure this gate exists to prevent.
+
+- Every entrypoint in the inventory is resolved to ✅, none left ❌.
+- Each entrypoint's path is traced through the downstream layers in
+  `analysis/_trace_targets.md` to a real sink or explicitly cleared, not stopped
+  at the view.
+- The Authorization Model pass ran: the access gate is mapped, sibling endpoints
+  compared, and IDOR and unauthenticated privileged paths checked.
+- `analysis/_rounds.md` shows two consecutive rounds that added no new source, no
+  new traced path, and no new issue.
+
+If any item fails, run another round. State which items pass when you report.
 
 ## On Finish
 
+Report the confirmed findings, the ones with a reproduced PoC, separately from
+the suspected ones still blocked on verification, so the two are never conflated.
 Append a row to the audit history in `security-review-memory.md`, and ask the
 operator which findings were false positives. Record those under "Confirmed false
 positives" so future rounds skip them.

codejury-0.19.0/codejury/detection.py

@@ -0,0 +1,56 @@
+"""File and path classification config, loaded from `data/detection.yaml`.
+
+What the engine treats as a source file, a dependency manifest, a noise
+directory, or test code, across ecosystems. Kept in data so the implementation
+enumerates no language itself: adding a language is a data edit, not a code
+change. This is distinct from a guide's stack detection in `guides.py`, which
+decides which language, framework, or protocol applies.
+"""
+
+from __future__ import annotations
+
+import fnmatch
+from dataclasses import dataclass
+from functools import lru_cache
+
+import yaml
+
+from codejury.resources import DETECTION_FILE
+
+
+@dataclass(frozen=True)
+class Detection:
+    skip_dirs: frozenset[str]            # directory names that are noise, never walked
+    source_extensions: frozenset[str]    # extensions whose content is scanned for markers
+    config_extensions: frozenset[str]    # config extensions also sampled when detecting the stack
+    manifests: tuple[str, ...]           # dependency-manifest filenames read to detect the stack
+    test_dirs: frozenset[str]            # directory segments that mark test code
+    test_name_patterns: tuple[str, ...]  # filename globs that mark a test file
+
+    @property
+    def detection_extensions(self) -> frozenset[str]:
+        """Source plus config, the files sampled when detecting the stack."""
+        return self.source_extensions | self.config_extensions
+
+    def is_test_path(self, path: str) -> bool:
+        """True when a path is test code, by a test directory segment or a
+        test-file naming convention. Conservative, so a production file is not
+        suppressed."""
+        parts = path.replace("\\", "/").split("/")
+        if any(p in self.test_dirs for p in parts[:-1]):
+            return True
+        name = parts[-1].lower()
+        return any(fnmatch.fnmatch(name, pat) for pat in self.test_name_patterns)
+
+
+@lru_cache(maxsize=1)
+def load_detection() -> Detection:
+    data = yaml.safe_load(DETECTION_FILE.read_text(encoding="utf-8")) or {}
+    return Detection(
+        skip_dirs=frozenset(data.get("skip_dirs", [])),
+        source_extensions=frozenset(data.get("source_extensions", [])),
+        config_extensions=frozenset(data.get("config_extensions", [])),
+        manifests=tuple(data.get("manifests", [])),
+        test_dirs=frozenset(data.get("test_dirs", [])),
+        test_name_patterns=tuple(data.get("test_name_patterns", [])),
+    )

{codejury-0.18.0 → codejury-0.19.0}/codejury/diff/engine.py

@@ -25,7 +25,7 @@ def guides_for_diff(diff: str) -> str:
     Lives here, not in the shared guides module, because parsing a diff is a
     diff-path concern."""
     paths = _DIFF_PATH.findall(diff)
-    return "\n\n---\n\n".join(g.body for g in select_guides(paths, text=diff))
+    return "\n\n---\n\n".join(g.body for g in select_guides(paths, source_text=diff))
 
 
 class AuditError(RuntimeError):

{codejury-0.18.0 → codejury-0.19.0}/codejury/diff/findings_filter.py

@@ -13,26 +13,7 @@ from __future__ import annotations
 
 from dataclasses import dataclass, field
 
-# directory segments that mark test code
-_TEST_DIRS = frozenset({
-    "test", "tests", "__tests__", "__mocks__", "mocks", "fixtures", "testdata", "e2e", "spec", "specs",
-})
-
-
-def _is_test_path(path: str) -> bool:
-    parts = path.replace("\\", "/").split("/")
-    if any(p in _TEST_DIRS for p in parts[:-1]):  # a directory segment, not the filename
-        return True
-    name = parts[-1].lower()
-    if name == "conftest.py":
-        return True
-    stem = name.rsplit(".", 1)[0]
-    return (
-        stem.startswith("test_")
-        or stem.endswith("_test")
-        or stem.endswith(".test")
-        or stem.endswith(".spec")
-    )
+from codejury.detection import load_detection
 
 
 @dataclass(frozen=True, kw_only=True)
@@ -53,7 +34,7 @@ class FindingsFilter:
         if f.confidence < self.min_confidence:
             return f"confidence {f.confidence:.2f} below floor {self.min_confidence:.2f}"
         path = f.file or ""
-        if self.drop_test_paths and _is_test_path(path):
+        if self.drop_test_paths and load_detection().is_test_path(path):
             return "test path (test/mock/fixture directory or test-file naming)"
         match = next((e for e in self.exclude_paths if e and e in path), None)
         if match: