codejury 0.19.0__tar.gz → 0.20.0__tar.gz

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

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: codejury
-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
+Version: 0.20.0
+Summary: AI code security review for diffs and whole repositories.
 Author: AISecLabs
 License-Expression: MIT
 Project-URL: Homepage, https://github.com/aiseclabs/codejury
@@ -40,52 +40,61 @@ Dynamic: license-file
 
 > AI code security review for diffs and whole repositories.
 
-It runs two paths matched to their nature.
+codejury runs two paths matched to their nature.
 
 - **Diff Review** is coded. It audits a pull request diff for newly introduced
   exploitable risk, as a single balanced LLM call or an adversarial Finder,
   Challenger, and Judge pass that trades roughly 3x the cost for extra recall on
-  subtle flaws that span files.
-- **Repo Review** is agent driven. It is a methodology an interactive agent such
-  as Claude Code or Codex runs to map a codebase attack surface, trace inputs to
-  sinks across files, verify issues with a real PoC, and iterate over rounds with
-  a persistent memory. A whole repository is too large for one LLM call, so it
-  ships the methodology and scaffolds the workspace instead of running a
-  pipeline.
-
-Security knowledge lives in rich vulnerability classes under `codejury/data/vulnerabilities/*.md`, with a
-vulnerable and a secure example per language, injected into the audit prompt
-rather than buried in code.
+  subtle flaws that span files. One command in, findings out.
+- **Repo Review** is agent driven. A whole repository is too large for one LLM
+  call, so codejury scaffolds a workspace and hands an interactive agent such as
+  Claude Code or Codex a methodology to run. The agent maps the attack surface,
+  traces inputs to sinks across files, verifies issues with a real PoC, and
+  iterates over rounds with a persistent memory.
+
+Security knowledge is data, not code. Vulnerability classes live in
+`codejury/data/vulnerabilities/*.md` with a vulnerable and a secure example per
+language, and the stack guides live under `data/languages`, `data/frameworks`,
+and `data/protocols`. The engine stays language neutral and names no framework,
+so adding a stack is a drop-in markdown file.
 
 ## Install
 
 ```bash
-pip install codejury                 # core
-pip install "codejury[anthropic]"    # add a backend, also openai or litellm
+pip install codejury                       # core
+pip install "codejury[anthropic]"          # add a backend, also openai or litellm
+codejury install-slash-command             # Claude Code, ~/.claude/commands/
+codejury install-slash-command --agent codex   # Codex, ~/.codex/prompts/
 ```
 
+`install-slash-command` copies the `/codejury-review` command into the agent's
+command directory. The command body is the same for every agent, only the
+directory differs, so pass `--dir` for any other agent. The repo review itself is
+agent neutral, so even without the command you can run `codejury review` and
+tell any agent to follow the methodology it writes.
+
 ## Diff Review
 
 ```bash
 # audit a diff file
-codejury review diff --diff-file changes.diff
+codejury diff --diff-file changes.diff
 
 # audit a git range in a repo
-codejury review diff --repo /path/to/app --git-range origin/main...HEAD
+codejury diff --repo /path/to/app --git-range origin/main...HEAD
 
 # from stdin
-git diff HEAD~1 | codejury review diff
+git diff HEAD~1 | codejury diff
 
 # adversarial mode, more recall on subtle flaws, about 3x the cost
-codejury review diff --diff-file changes.diff --mode adversarial
+codejury diff --diff-file changes.diff --mode adversarial
 
 # CI gate and SARIF
-codejury review diff --diff-file changes.diff --format sarif --fail-on high
+codejury diff --diff-file changes.diff --format sarif --fail-on high
 ```
 
 Configure a backend with `--provider`, `--model`, `--api-key`, `--api-base`, or
 the `CODEJURY_API_KEY`, `CODEJURY_MODEL`, and `CODEJURY_API_BASE` environment
-variables. `codejury review diff --dry-run` exercises the engine with a mock
+variables. `codejury diff --dry-run` exercises the engine with a mock
 provider and no key, and falls back to a built in demo diff when you pass none.
 
 ### Choosing a Model and Mode
@@ -120,17 +129,49 @@ request.
 
 ## Repo Review
 
+Repo Review does not scan and print findings. It sets up a review for an agent to
+run, because a whole repository needs many rounds of reading, cross-file tracing,
+and PoC work that an agent does, not a single call.
+
 ```bash
-codejury review repo /path/to/your/repo
+codejury review /path/to/your/repo
 ```
 
-This scaffolds a review workspace with `entrypoints/`, `issues/`, `analysis/`,
-and a `security-review-memory.md`, seeds the entrypoint inventory from a
-deterministic scan, and prints the methodology. Run it with an interactive agent.
-It reads the methodology and the vulnerability classes, maps the attack surface, traces inputs to
-sinks across files, records high confidence issues with a PoC, and asks you to
-confirm credentials or false positives along the way. Nothing runs against
-production.
+This detects the stack, seeds the entrypoint inventory and the downstream trace
+targets from a deterministic scan, writes the methodology to
+`<workspace>/METHODOLOGY.md`, and prints a short pointer. It creates the
+workspace:
+
+```
+entrypoints/   the candidate entrypoint files to start from
+issues/        one write-up per confirmed or suspected issue
+pocs/          a runnable PoC per issue, same name as the issue
+analysis/      _trace_targets.md, the round ledger, and trace notes
+security-review-memory.md
+```
+
+Then run it with an interactive agent. In Claude Code or Codex:
+
+```
+/codejury-review /path/to/your/repo
+```
+
+Any agent works, the slash command is just a shortcut. Without it, tell the agent
+to follow the `METHODOLOGY.md` the scaffold wrote.
+
+The agent follows `METHODOLOGY.md`: it maps the attack surface including non HTTP
+sources, traces each input to its sink through the downstream layers, runs an
+Authorization Model pass for missing-auth and IDOR, and follows a control into a
+library when an entrypoint delegates it. It keeps going until a Completeness Gate
+passes, two consecutive rounds that add nothing new. It confirms each issue with
+a real PoC against a sandbox or dev environment and asks you for any credential or
+test data it needs. Only a reproduced PoC is a confirmed finding, and nothing
+runs against production.
+
+The supported stacks today are Python with Django, Celery, Flask, and FastAPI,
+Go with Gin and Echo, JavaScript and TypeScript with Express and NestJS, and the
+OAuth and OIDC protocol. The methodology still works on an unguided stack, it just
+leans more on the agent's own knowledge.
 
 ## Findings
 
@@ -142,6 +183,15 @@ production config leaks.
 
 ## Extending
 
-Add a vulnerability class by dropping a new file `codejury/data/vulnerabilities/<class>.md`
-with the standard frontmatter of title, impact, tags, and triggers plus a
-vulnerable and a secure example. It is data, no code change needed.
+Knowledge is data, so extending codejury is a drop-in markdown file with no code
+change.
+
+- A vulnerability class: `codejury/data/vulnerabilities/<class>.md` with
+  frontmatter of title, impact, tags, and triggers, plus a vulnerable and a
+  secure example.
+- A language or framework: `codejury/data/languages/<lang>.md` or
+  `codejury/data/frameworks/<lang>/<framework>.md`, declaring its detect signals,
+  entrypoint markers, and downstream logic layers.
+- A protocol such as OAuth: `codejury/data/protocols/<name>.md`, detected by
+  language neutral content tokens.
+```

codejury-0.20.0/README.md

@@ -0,0 +1,166 @@
+```
+ ██████╗ ██████╗ ██████╗ ███████╗     ██╗██╗   ██╗██████╗ ██╗   ██╗
+██╔════╝██╔═══██╗██╔══██╗██╔════╝     ██║██║   ██║██╔══██╗╚██╗ ██╔╝
+██║     ██║   ██║██║  ██║█████╗       ██║██║   ██║██████╔╝ ╚████╔╝
+██║     ██║   ██║██║  ██║██╔══╝  ██   ██║██║   ██║██╔══██╗  ╚██╔╝
+╚██████╗╚██████╔╝██████╔╝███████╗╚█████╔╝╚██████╔╝██║  ██║   ██║
+ ╚═════╝ ╚═════╝ ╚═════╝ ╚══════╝ ╚════╝  ╚═════╝ ╚═╝  ╚═╝   ╚═╝
+```
+
+> AI code security review for diffs and whole repositories.
+
+codejury runs two paths matched to their nature.
+
+- **Diff Review** is coded. It audits a pull request diff for newly introduced
+  exploitable risk, as a single balanced LLM call or an adversarial Finder,
+  Challenger, and Judge pass that trades roughly 3x the cost for extra recall on
+  subtle flaws that span files. One command in, findings out.
+- **Repo Review** is agent driven. A whole repository is too large for one LLM
+  call, so codejury scaffolds a workspace and hands an interactive agent such as
+  Claude Code or Codex a methodology to run. The agent maps the attack surface,
+  traces inputs to sinks across files, verifies issues with a real PoC, and
+  iterates over rounds with a persistent memory.
+
+Security knowledge is data, not code. Vulnerability classes live in
+`codejury/data/vulnerabilities/*.md` with a vulnerable and a secure example per
+language, and the stack guides live under `data/languages`, `data/frameworks`,
+and `data/protocols`. The engine stays language neutral and names no framework,
+so adding a stack is a drop-in markdown file.
+
+## Install
+
+```bash
+pip install codejury                       # core
+pip install "codejury[anthropic]"          # add a backend, also openai or litellm
+codejury install-slash-command             # Claude Code, ~/.claude/commands/
+codejury install-slash-command --agent codex   # Codex, ~/.codex/prompts/
+```
+
+`install-slash-command` copies the `/codejury-review` command into the agent's
+command directory. The command body is the same for every agent, only the
+directory differs, so pass `--dir` for any other agent. The repo review itself is
+agent neutral, so even without the command you can run `codejury review` and
+tell any agent to follow the methodology it writes.
+
+## Diff Review
+
+```bash
+# audit a diff file
+codejury diff --diff-file changes.diff
+
+# audit a git range in a repo
+codejury diff --repo /path/to/app --git-range origin/main...HEAD
+
+# from stdin
+git diff HEAD~1 | codejury diff
+
+# adversarial mode, more recall on subtle flaws, about 3x the cost
+codejury diff --diff-file changes.diff --mode adversarial
+
+# CI gate and SARIF
+codejury diff --diff-file changes.diff --format sarif --fail-on high
+```
+
+Configure a backend with `--provider`, `--model`, `--api-key`, `--api-base`, or
+the `CODEJURY_API_KEY`, `CODEJURY_MODEL`, and `CODEJURY_API_BASE` environment
+variables. `codejury diff --dry-run` exercises the engine with a mock
+provider and no key, and falls back to a built in demo diff when you pass none.
+
+### Choosing a Model and Mode
+
+Detection quality is dominated by the model first, then the mode. On real diff
+probes:
+
+- A strong model at the Claude Sonnet tier in standard mode caught every planted
+  vulnerability with almost no false positives. A weaker model raised false
+  positives in both modes, so the model is the lever that matters most.
+- Adversarial mode did not lower false positives over standard on those probes
+  and costs about 3x. Reach for it to gain recall on subtle logic that spans
+  files, not as a way to cut false positives.
+
+Default to standard mode with a strong model, set with `--model` or
+`CODEJURY_MODEL`. False positives are held down by the do not report list and the
+post filter, not by the mode.
+
+### Use in CI with GitHub Actions
+
+Audit every pull request and surface findings in the code scanning tab. Copy
+`examples/codejury-pr-review.yml` into `.github/workflows/`, add a
+`CODEJURY_API_KEY` repository secret, and it will
+
+1. diff the pull request against its base with `--git-range origin/<base>...HEAD`,
+2. write SARIF and upload it with `github/codeql-action/upload-sarif`,
+3. fail the check on a HIGH or CRITICAL finding with `--fail-on high`.
+
+The job makes one model call per pull request in standard mode. The SARIF is
+uploaded even when the gate fails, so findings always show up on the pull
+request.
+
+## Repo Review
+
+Repo Review does not scan and print findings. It sets up a review for an agent to
+run, because a whole repository needs many rounds of reading, cross-file tracing,
+and PoC work that an agent does, not a single call.
+
+```bash
+codejury review /path/to/your/repo
+```
+
+This detects the stack, seeds the entrypoint inventory and the downstream trace
+targets from a deterministic scan, writes the methodology to
+`<workspace>/METHODOLOGY.md`, and prints a short pointer. It creates the
+workspace:
+
+```
+entrypoints/   the candidate entrypoint files to start from
+issues/        one write-up per confirmed or suspected issue
+pocs/          a runnable PoC per issue, same name as the issue
+analysis/      _trace_targets.md, the round ledger, and trace notes
+security-review-memory.md
+```
+
+Then run it with an interactive agent. In Claude Code or Codex:
+
+```
+/codejury-review /path/to/your/repo
+```
+
+Any agent works, the slash command is just a shortcut. Without it, tell the agent
+to follow the `METHODOLOGY.md` the scaffold wrote.
+
+The agent follows `METHODOLOGY.md`: it maps the attack surface including non HTTP
+sources, traces each input to its sink through the downstream layers, runs an
+Authorization Model pass for missing-auth and IDOR, and follows a control into a
+library when an entrypoint delegates it. It keeps going until a Completeness Gate
+passes, two consecutive rounds that add nothing new. It confirms each issue with
+a real PoC against a sandbox or dev environment and asks you for any credential or
+test data it needs. Only a reproduced PoC is a confirmed finding, and nothing
+runs against production.
+
+The supported stacks today are Python with Django, Celery, Flask, and FastAPI,
+Go with Gin and Echo, JavaScript and TypeScript with Express and NestJS, and the
+OAuth and OIDC protocol. The methodology still works on an unguided stack, it just
+leans more on the agent's own knowledge.
+
+## Findings
+
+Each finding carries a file and line, a severity and category, a concrete exploit
+scenario, a recommendation, and a confidence. A false positive filter drops test
+paths, mock paths, and low confidence noise. The model is also told not to report
+dependency CVEs, style notes, speculation, or risks that only matter when
+production config leaks.
+
+## Extending
+
+Knowledge is data, so extending codejury is a drop-in markdown file with no code
+change.
+
+- A vulnerability class: `codejury/data/vulnerabilities/<class>.md` with
+  frontmatter of title, impact, tags, and triggers, plus a vulnerable and a
+  secure example.
+- A language or framework: `codejury/data/languages/<lang>.md` or
+  `codejury/data/frameworks/<lang>/<framework>.md`, declaring its detect signals,
+  entrypoint markers, and downstream logic layers.
+- A protocol such as OAuth: `codejury/data/protocols/<name>.md`, detected by
+  language neutral content tokens.
+```

codejury-0.20.0/codejury/__main__.py

@@ -0,0 +1,10 @@
+"""Entry point for `python -m codejury`, mirroring the `codejury` console script.
+
+Lets the tool run without the console script on PATH, for example from a fresh
+shell that has not activated the project venv: `python -m codejury ...`.
+"""
+
+from codejury.cli import main
+
+if __name__ == "__main__":
+    raise SystemExit(main())

{codejury-0.19.0 → codejury-0.20.0}/codejury/cli.py

@@ -2,13 +2,13 @@
 
 Two paths matched to their nature:
 
-- ``review diff`` runs the coded diff engine over a unified diff: a single
-  balanced call (standard) or the adversarial Finder/Challenger/Judge pass.
-- ``review repo`` scaffolds a workspace and prints the methodology for an
+- ``diff`` runs the coded diff engine over a unified diff: a single balanced call
+  (standard) or the adversarial Finder/Challenger/Judge pass.
+- ``review <dir>`` scaffolds a workspace and prints the methodology for an
   interactive agent to run a whole-repo review (it does not run an LLM pipeline,
   which a single call cannot do for a whole codebase).
 
-``review diff --dry-run`` exercises the engine with a mock provider and no key.
+``diff --dry-run`` exercises the engine with a mock provider and no key.
 The audit orchestration itself lives in ``codejury.diff.runner``.
 """
 
@@ -17,6 +17,7 @@ from __future__ import annotations
 import argparse
 import subprocess
 import sys
+from pathlib import Path
 
 from codejury import __version__
 from codejury.report import gate, render
@@ -92,12 +93,17 @@ def main(argv: list[str] | None = None) -> int:
     parser.add_argument("--version", action="version", version=f"codejury {__version__}")
     sub = parser.add_subparsers(dest="command")
 
-    review = sub.add_parser("review", help="review code for security findings")
-    rsub = review.add_subparsers(dest="scope")
-    _add_audit_args(rsub.add_parser("diff", help="audit a unified diff (the coded engine)"))
-    repo = rsub.add_parser("repo", help="scaffold a whole-repo review for an interactive agent")
-    repo.add_argument("directory", help="target repository to review")
-    repo.add_argument("--workspace", default="codejury-review", help="where to create the review workspace")
+    _add_audit_args(sub.add_parser("diff", help="audit a unified diff (the coded engine)"))
+
+    review = sub.add_parser("review", help="scaffold a whole-repo review for an interactive agent")
+    review.add_argument("directory", help="target repository to review")
+    review.add_argument("--workspace", default="codejury-review", help="where to create the review workspace")
+
+    inst = sub.add_parser("install-slash-command",
+                          help="install the /codejury-review slash command for an agent")
+    inst.add_argument("--agent", choices=("claude", "codex"), default="claude",
+                      help="which agent's command directory to install into")
+    inst.add_argument("--dir", default=None, help="explicit target directory, overrides --agent")
 
     args = parser.parse_args(argv)
     try:
@@ -109,8 +115,7 @@ def main(argv: list[str] | None = None) -> int:
 
 
 def _dispatch(args, parser) -> int:
-    scope = getattr(args, "scope", None)
-    if args.command == "review" and scope == "diff":
+    if args.command == "diff":
         if args.dry_run:
             provider = MockProvider(default=_MOCK_REPLY)
             model = "mock"
@@ -129,23 +134,38 @@ def _dispatch(args, parser) -> int:
         print(render(args.fmt, kept))
         return 1 if gate(kept, args.fail_on) else 0
 
-    if args.command == "review" and scope == "repo":
+    if args.command == "review":
         res = scaffold(args.directory, args.workspace)
-        print(f"Workspace: {res.workspace}", file=sys.stderr)
+        (Path(res.workspace) / "METHODOLOGY.md").write_text(res.methodology, encoding="utf-8")
+        print(f"Workspace ready: {res.workspace}", file=sys.stderr)
         if res.guides:
-            print(f"Detected stack: {', '.join(res.guides)}. Notes in {res.workspace}/_stack.md", file=sys.stderr)
+            print(f"Detected stack: {', '.join(res.guides)}, notes in {res.workspace}/_stack.md", file=sys.stderr)
         print(f"Flagged {len(res.candidate_files)} candidate entrypoint files into "
               f"{res.workspace}/entrypoints/_entrypoints.md", file=sys.stderr)
-        print(f"Memory: {res.memory_path}", file=sys.stderr)
-        print("\nRun this review with an interactive agent (Claude Code / Codex) using the methodology below.\n")
-        print(res.methodology)
+        print(f"Methodology: {res.workspace}/METHODOLOGY.md", file=sys.stderr)
+        print(
+            "This command sets up the review, it does not find the issues itself. Next, have an "
+            f"interactive agent follow {res.workspace}/METHODOLOGY.md to run the review, or use the "
+            "/codejury-review command in Claude Code or Codex. Findings are written to "
+            f"{res.workspace}/issues/."
+        )
         return 0
 
-    if args.command == "review":  # no scope given
-        print("usage: codejury review {diff,repo} ...", file=sys.stderr)
-        print("  diff   audit a unified diff for security findings", file=sys.stderr)
-        print("  repo   scaffold a whole-repo review for an interactive agent", file=sys.stderr)
-        return 1
+    if args.command == "install-slash-command":
+        from codejury.resources import COMMANDS_DIR
+        # the command body is portable, only the directory differs per agent
+        agent_dirs = {
+            "claude": Path.home() / ".claude" / "commands",
+            "codex": Path.home() / ".codex" / "prompts",
+        }
+        target_dir = Path(args.dir) if args.dir else agent_dirs[args.agent]
+        target_dir.mkdir(parents=True, exist_ok=True)
+        name = "codejury-review.md"
+        dst = target_dir / name
+        dst.write_text((COMMANDS_DIR / name).read_text(encoding="utf-8"), encoding="utf-8")
+        print(f"Installed slash command to {dst}")
+        print("Run it in the agent with: /codejury-review <repository>")
+        return 0
 
     parser.print_help()
     return 1

codejury-0.20.0/codejury/data/commands/codejury-review.md

@@ -0,0 +1,29 @@
+---
+description: Run a codejury whole-repo security review on a repository, interactively
+---
+Run a codejury whole-repository security review of: $ARGUMENTS
+
+1. Scaffold the workspace:
+
+   ```
+   codejury review $ARGUMENTS --workspace /tmp/codejury-review
+   ```
+
+   If `codejury` is not on PATH it is a pip-installed console script, so activate
+   the project venv first, for example `. .venv/bin/activate`, or run it through
+   that venv's Python, for example `python -m codejury`.
+
+2. Read `<workspace>/METHODOLOGY.md` and follow it to completion. It is the single
+   source of truth for how to run the review, the entrypoint map, the trace
+   targets, the Authorization Model pass, the dependency-control checks, the round
+   ledger, and the Completeness Gate. Do not improvise a different process.
+
+3. Verify each issue with a real PoC, human in the loop. Ask me for any
+   credential, test account, or MFA step you need. Never touch production, never
+   use real credentials, and never run a destructive action without my go-ahead.
+   Only a reproduced PoC is a confirmed finding.
+
+4. Report confirmed findings, the ones with a reproduced PoC, separately from
+   suspected ones still blocked on verification, as a table: title, class,
+   `file:line`, exploit, verification status. The issue files live in the
+   workspace `issues/`.

{codejury-0.19.0 → codejury-0.20.0}/codejury/data/detection.yaml

@@ -4,7 +4,7 @@
 # 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"]
+skip_dirs: [".git", ".venv", "venv", "node_modules", "__pycache__", ".mypy_cache", ".pytest_cache", "build", "dist", "target", "out", ".tox", ".eggs", ".next", ".nuxt"]
 
 source_extensions: [".py", ".js", ".ts", ".tsx", ".jsx", ".mjs", ".go", ".rb", ".java", ".kt", ".php", ".cs", ".scala", ".rs"]
 

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

@@ -147,10 +147,12 @@ exploitable exposure, so it is in scope. See "Controls That Live in a Library".
 
 ## Recording an Issue
 
-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:
+Write one `issues/<name>.md` per issue, the write-up only, and save its PoC as a
+real runnable file `pocs/<name>.<ext>` with the **same `<name>`** so the two pair
+one to one, a script or an `.http` file, not a sketch in prose and not a `.md`.
+Keep `issues/` write-ups and `pocs/` scripts in their own directories, do not mix
+them. 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>
@@ -167,7 +169,7 @@ positive, so do not report it. Each issue file must have:
 (end-to-end, actionable steps)
 
 ## PoC
-(the path to `issues/poc_<name>.<ext>` and how to run it)
+(the path to `pocs/<name>.<ext>` and how to run it)
 
 ## Verification
 (the actual output of running the PoC, or the exact blocker)

{codejury-0.19.0 → codejury-0.20.0}/codejury/repo/scaffold.py

@@ -151,7 +151,7 @@ def scaffold(target: str | Path, workspace: str | Path) -> ScaffoldResult:
     project = target.name
     ws = Path(workspace) / project
     created: list[str] = []
-    for sub in ("entrypoints", "issues", "analysis"):
+    for sub in ("entrypoints", "issues", "pocs", "analysis"):
         d = ws / sub
         if not d.exists():
             d.mkdir(parents=True, exist_ok=True)

{codejury-0.19.0 → codejury-0.20.0}/codejury/resources.py

@@ -14,3 +14,4 @@ FRAMEWORKS_DIR = _DATA / "frameworks"  # per-framework review guides (how the ta
 PROTOCOLS_DIR = _DATA / "protocols"    # protocol guides such as oauth (what to check)
 METHODOLOGIES_DIR = _DATA / "methodologies"  # repo-review methodology and memory template
 DETECTION_FILE = _DATA / "detection.yaml"    # file and path classification across ecosystems
+COMMANDS_DIR = _DATA / "commands"            # Claude Code slash commands shipped for install