OpenAI Codex Security

No entries match these filters. Clear filters

1. docs update Oct 8, 2026 · issue 097

   OpenAI Codex Security launches with CLI/SDK, desktop workbench, and cloud GitHub scanning via @openai/codex-security⁠︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄⁠

   └──▷ TRY IT
   Preflight a repository and run a local security scan from the terminal on first use.
   copy

   $ npx @openai/codex-security --help

   • Adds @openai/codex-security npm package providing a CLI invocable via npx @openai/codex-security --help for local and CI-based security scans.⁠︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄⁠
   • Adds TypeScript SDK (also via @openai/codex-security) to embed scanning, progress reporting, and cost controls into applications or developer tools.
   • CLI supports SARIFSARIFStatic Analysis Results Interchange Format, a standard for sharing code-analysis findings, including locations and rule details. It lets scanners report results to a common review interface. upload, CSV-based bulk-scan inventories, resumable campaigns, severity policy enforcement, and false-positive feedback tracking across repositories.
   • Adds a Security workbench in the ChatGPT desktop app with three dedicated views — Scans, Findings, and Repositories — for tracking scan progress and results.
   • Adds Codex Security Cloud plugin for continuous or one-time scanning of connected GitHub repositories in Codex cloud, with isolated validation and proposed patch/PR workflow.

   +3 more show less

   • Supports running security scans in CI to review pull-request changes, preserve artifacts, and enforce severity policy.
   • Supports architecture and security policy input, estimated cost limits, and pre-commit checks via the CLI.
   • Enables exporting findings as portable artifacts or routing them to approval-gated tracking destinations.

   8 details in Everything

2. docs update Oct 4, 2026 · issue 094

   OpenAI Codex Security launches with CLI (@openai/codex-security), TypeScript SDK, desktop workbench, and GitHub cloud scanning.⁠︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄⁠

   └──▷ TRY IT
   Preflight a repository and run a first local security scan from the terminal.
   copy

   $ npx @openai/codex-security --help

   • Adds the @openai/codex-security npm package, providing a CLI (npx @openai/codex-security --help) and TypeScript SDK for running security scans from a terminal, CI pipeline, or custom application.⁠︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄⁠
   • Supports SARIFSARIFStatic Analysis Results Interchange Format, a standard for sharing code-analysis findings, including locations and rule details. It lets scanners report results to a common review interface. upload and severity-policy enforcement when running scans in CI, enabling PR-gating on vulnerability severity.
   • Supports bulk security scans via GitHub repository discovery or a CSV inventory file, with resumable campaign support and cross-scan finding tracking.
   • Adds a Codex Security plugin for the ChatGPT desktop app, opening a Security workbench with dedicated Scans, Findings, and Repositories panels.
   • Adds Codex Security Cloud plugin (research preview) for continuous or one-time scanning of connected GitHub repositories in Codex cloud, with isolated validation and patch proposal.

   +3 more show less

   • Supports exporting findings as portable artifacts and routing approved findings to approval-gated tracking destinations.
   • Supports false-positive feedback recording, architecture/security-policy injection, and estimated cost-limit configuration in the CLI.
   • Supports TypeScript SDK integration for selecting scan targets, inspecting results, tracking scan progress, and cancelling scans programmatically.

   8 details in Everything

3. docs update Sep 25, 2026 · issue 085

   Codex Security 0.1.25 adds artifact retention, broader file-type coverage, and enrollment-aware access warnings⁠︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄⁠

   • Includes changed GitHub ActionsGitHub ActionsGitHub's built-in CI/CD system that runs automated workflows triggered by repository events, letting cyber tools automate testing, building, and releasing without managing separate pipeline infrastructure. workflow files in change scans, and recognizes .cjs, .cts, .mts, and .tf files during repository review.⁠︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄⁠
   • Saves scan artifacts through the plugin during a running scan so they remain available with final results and recovery checkpoints.
   • Supports saving scan results on filesystems that don't support hard links.
   • Shows an enrollment link when access isn't granted, or a warning when access can't be verified, with a fresh denied result still triggering the enrollment warning.
   • Requires OPENAI_API_KEY for deep scan workers without a Codex account when the selected provider requires OpenAI authentication.

   +5 more show less

   • Marks coverage as partial when Codex can't verify findings, review receipts, or related evidence.
   • Allows up to two minutes for the plugin's tool server to start.
   • Uses Codex's bundled Node.js runtime when starting the plugin, including on Windows installations where packaged executables can't run directly.
   • Continues a scan without an access warning when the Daybreak check is unavailable or inconclusive.
   • Dismisses setup when not needed and retains that preference for later sessions.
   • Includes changed GitHub ActionsGitHub ActionsGitHub's built-in CI/CD system that runs automated workflows triggered by repository events, letting cyber tools automate testing, building, and releasing without managing separate pipeline infrastructure. workflow files in change scans, and recognizes .cjs, .cts, .mts, and .tf files during repository review.⁠︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄⁠
   • Saves scan artifacts through the plugin during a running scan so they remain available with final results and recovery checkpoints.
   • Shows an enrollment link when access isn't granted, or a warning when access can't be verified, with a fresh denied result still triggering the enrollment warning.
   • Requires OPENAI_API_KEY for deep scan workers without a Codex account when the selected provider requires OpenAI authentication.
   • Marks coverage as partial when Codex can't verify findings, review receipts, or related evidence.

   +1 more show less

   • Dismisses setup when not needed and retains that preference for later sessions.

   4 more in Everything

4. npm-v0.1.30 Sep 23, 2026 · release notes

   Adds ability to review original observation records through a host

   └──▷ GET THIS VERSION

   copy

   $ git clone --branch npm-v0.1.30 https://github.com/openai/codex-security.git
   # already have the repo? check out this version:
   $ git checkout npm-v0.1.30

5. npm-v0.1.29 Sep 18, 2026 · release notes

   Add custom patch validation prompts and sortable dashboard tables

   └──▷ GET THIS VERSION

   copy

   $ git clone --branch npm-v0.1.29 https://github.com/openai/codex-security.git
   # already have the repo? check out this version:
   $ git checkout npm-v0.1.29

   • Enables sorting on dashboard table columns via new interactive controls

   1 detail in Everything

6. npm-v0.1.28 Sep 16, 2026 · release notes

   OpenAI Codex Security npm-v0.1.28 adds optional cost display, MCPMCPModel Context Protocol, a standard for connecting AI applications to external tools and data sources. A compatible server exposes capabilities an assistant can use through a common interface. artifact persistence, and universal text KB support.

   └──▷ GET THIS VERSION

   copy

   $ git clone --branch npm-v0.1.28 https://github.com/openai/codex-security.git
   # already have the repo? check out this version:
   $ git checkout npm-v0.1.28

   └──▷ TRY IT
   Run a scan without showing the cost breakdown.
   copy

   $ codex-security scan --cost <path>

   Pass a custom-named knowledge base file to the scanner.
   copy

   $ codex-security scan --kb my-knowledge-docs.txt <path>

   • --cost flag added to CLI to toggle the cost display for scans
   • Scan artifacts are now persisted when invoking the tool via MCP
   • CLI now accepts knowledge-base text files with any extension (no longer limited to specific filenames or types)

   3 details in Everything

7. docs update Sep 15, 2026 · issue 075

   Codex Security adds patch-risk assessment, fix verification, failed-scan recovery, and improved SARIFSARIFStatic Analysis Results Interchange Format, a standard for sharing code-analysis findings, including locations and rule details. It lets scanners report results to a common review interface. exports across v0.1.21–v0.1.24.⁠︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄⁠

   └──▷ TRY IT
   Assess whether a proposed patch is safe to merge before committing it to the repository.
   copy

   $ $codex-security:assess-patch-risk

   Confirm that a previously applied security fix actually resolves a reported finding, without touching repo files.
   copy

   $ $codex-security:verify-fix

   • Adds $codex-security:assess-patch-risk command to review a proposed change against exact revisions and source evidence, returning a recommendation to merge, revise, or make no change.⁠︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄⁠
   • Adds $codex-security:verify-fix command to check whether an existing patch resolves a reported security finding without modifying repository files or issue trackers, returning fixed, still_vulnerable, or inconclusive per finding.
   • Checks Daybreak access from within the plugin before a scan in desktop and CLI sessions signed in with ChatGPT, showing an enrollment link when access is not granted or a warning when access cannot be verified.
   • Recovers valid saved findings from a selected failed scan on request, without repeating the scan, while preserving the failed outcome.
   • Exports readable rule names, remediation guidance, CWECWECommon Weakness Enumeration, a catalog of recurring software and hardware weakness types. It describes classes of mistakes, such as injection, rather than individual vulnerability instances. tags, and security severity for GitHub code scanning in SARIF, while preserving finding identities, fingerprints, and source locations.

   +3 more show less

   • Shows individual readiness checks and their blocking or warning details in standard and change scan setup reports, and includes configured include and exclude paths in deep-scan reports.
   • Saves findings and pending candidates incrementally as deep-scan workers make progress, keeping valid results from failed, canceled, or interrupted scans.
   • Passes OpenAI API-key authentication to deep-scan workers and allows up to two minutes for the plugin tool server to start.
   • Adds $codex-security:assess-patch-risk command to review a proposed change against exact revisions and source evidence, returning a recommendation to merge, revise, or make no change.⁠︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄⁠
   • Adds $codex-security:verify-fix command to check whether an existing patch resolves a reported security finding without modifying repository files or issue trackers, returning fixed, still_vulnerable, or inconclusive per finding.
   • Checks Daybreak access from within the plugin before a scan in desktop and CLI sessions signed in with ChatGPT, showing an enrollment link when access is not granted or a warning when access cannot be verified.
   • Recovers valid saved findings from a selected failed scan on request, without repeating the scan, while preserving the failed outcome.
   • Saves findings and pending candidates incrementally as deep-scan workers make progress, keeping valid results from failed, canceled, or interrupted scans.

   3 more in Everything

8. npm-v0.1.26 Sep 8, 2026 · release notes

   New severity classification rubrics, GitLab PR creation via --create-pr, and finding history matching in v0.1.26

   └──▷ GET THIS VERSION

   copy

   $ git clone --branch npm-v0.1.26 https://github.com/openai/codex-security.git
   # already have the repo? check out this version:
   $ git checkout npm-v0.1.26

   • Add --create-pr flag to open draft GitLab merge requests for verified patches (includes self-hosted GitLab)
   • Classify finding severity with custom rubrics through CLI/SDK; saved assessments are reusable for Linear without altering original findings or sealed scan artifacts
   • Match repeated findings across scan history, preserving confirmed identities and related-finding relationships

   3 details in Everything

9. npm-v0.1.25 Sep 2, 2026 · release notes

   Mock scans via --mock, env-configurable embeddingsembeddingsLists of numbers a model produces to represent the meaning of text, images or code, so similar items sit close together. They power semantic search and RAG. URL (CODEX_SECURITY_EMBEDDINGS_URL), interactive budget increases, and sealed deduplication SDK function.

   └──▷ GET THIS VERSION

   copy

   $ git clone --branch npm-v0.1.25 https://github.com/openai/codex-security.git
   # already have the repo? check out this version:
   $ git checkout npm-v0.1.25

   └──▷ TRY IT
   Generate synthetic scan results for local testing without API costs or authentication
   copy

   $ codex-security scan --mock --format sarif > mock-results.sarif

   Configure the tool to send finding embeddings to a custom endpoint via environment variable
   copy

   $ export CODEX_SECURITY_EMBEDDINGS_URL=https://internal-endpoint.com/embed && codex-security scan .

   Programmatically handle budget limits in a Node.js SDK script
   typescript copy

   import { CodexSecurity } from '@openai/codex-security';
   const cs = new CodexSecurity({ onBudgetApproaching: () => console.warn('Near limit') });
   await cs.scanDirectory('./src');

   • scan --mock generates synthetic Standard scan results without authentication or model calls
   • Set CODEX_SECURITY_EMBEDDINGS_URL to configure the findings service's full embeddings endpoint
   • Interactive dashboard allows increasing a running scan's total budget when usage reaches 80% of its limit
   • onBudgetApproaching callback in the SDK allows programmatic handling of approaching budget limits
   • SDK adds deduplicateScanDirectory for complete, sealed deduplication outside local history

   5 details in Everything

10. docs update Aug 31, 2026 · issue 060

    Codex Security CLI gains a documented GitLab CI/CD pipeline for diff scanning, SARIFSARIFStatic Analysis Results Interchange Format, a standard for sharing code-analysis findings, including locations and rule details. It lets scanners report results to a common review interface. publishing, and verified automated remediation.

    └──▷ USE IT
    Scan only the committed diff in a protected merge request and publish findings to the GitLab Security dashboard via SARIF.
    .gitlab-ci.yml copy

    # .gitlab-ci.yml excerpt
    stages:
      - security_scan
      - security_gate
    
    codex-security:
      stage: security_scan
      image: node:26-bookworm-slim
      environment:
        name: codex-security/openai
        action: access
      variables:
        GIT_DEPTH: "0"
      before_script:
        - npm install --prefix /tmp/codex-security-cli --ignore-scripts --no-audit --no-fund @openai/codex-security@0.1.20
      script:
        - |
          CODEX_SECURITY_BIN="/tmp/codex-security-cli/node_modules/.bin/codex-security"
          RESULTS_DIR="/tmp/codex-security-results-$CI_JOB_ID"
          ARTIFACT_DIR="codex-security-artifacts"
          BASE_REVISION="$(git merge-base "$CI_MERGE_REQUEST_DIFF_BASE_SHA" "$CI_COMMIT_SHA")"
          install -d -m 700 "$RESULTS_DIR" "$ARTIFACT_DIR/results"
          codex_security_api_key="$CODEX_SECURITY_API_KEY"
          unset CODEX_SECURITY_API_KEY
          OPENAI_API_KEY="$codex_security_api_key" \
            "$CODEX_SECURITY_BIN" scan . \
              --diff "$BASE_REVISION" \
              --head "$CI_COMMIT_SHA" \
              --auth api-key \
              --output-dir "$RESULTS_DIR" \
              --json
          "$CODEX_SECURITY_BIN" export "$RESULTS_DIR" \
            --export-format sarif \
            --source-root "$CI_PROJECT_DIR" \
            --output "$ARTIFACT_DIR/results.sarif"
      artifacts:
        when: always
        access: maintainer
        expire_in: 7 days
        paths:
          - codex-security-artifacts/
        reports:
          sarif: codex-security-artifacts/results.sarif

    Enable automated remediation and draft MR publishing for high/critical findings on the protected default branch.
    .gitlab-ci.yml copy

    # GitLab CI/CD protected variables to set in Settings > CI/CD > Variables:
    #
    # CODEX_SECURITY_ENABLE_REMEDIATION   = true          (protected, masked)
    # CODEX_SECURITY_VERIFICATION_COMMAND = pytest tests/security/test_vuln.py  (protected)
    # CODEX_SECURITY_SETUP_COMMAND        = pip install -r requirements.txt     (protected)
    # CODEX_SECURITY_CREATE_MR            = true          (protected)
    # GITLAB_REMEDIATION_TOKEN            = <token>       (protected, masked, scoped to codex-security/publish)
    # CODEX_SECURITY_MR_TEST_COMMAND      = pytest tests/security/test_vuln.py  (unprotected)

    Opt in to full-repository scans on every push to the protected default branch, in addition to the default MR diff scans.
    .gitlab-ci.yml copy

    # In .gitlab-ci.yml variables block:
    variables:
      CODEX_SECURITY_FULL_SCAN_DEFAULT_BRANCH: "true"
      CODEX_SECURITY_SCHEDULED_DEEP_SCAN: "true"

    • Adds a GitLab CI/CD pipeline integration that installs @openai/codex-security@0.1.20 and runs codex-security scan . --diff <base> --head <sha> --auth api-key --output-dir <dir> --json to scan committed diffs in protected merge requests.
    • Exports scan results with codex-security export <results-dir> --export-format sarif --source-root <project-dir> --output <file>.sarif for ingestion into GitLab Ultimate 19.2+ via the reports.sarif artifact key.
    • Introduces a two-stage scan/gate pattern: a codex-security job in security_scan publishes SARIF artifacts, then a separate codex-security-gate job in security_gate restores the scanner exit code (0 = pass, 1 = findings, 2 = incomplete/error).
    • Adds optional automated remediation controlled by the CODEX_SECURITY_ENABLE_REMEDIATION=true protected variable, which triggers validate, patch, and verify-fix subcommands in credential-isolated stages.
    • Adds CODEX_SECURITY_VERIFICATION_COMMAND protected variable to specify the regression test that must exit 1 before a patch and 0 after — used by verify-fix to confirm a fix is fixed, still_vulnerable, or inconclusive before publishing.

    +4 more show less

    • Adds optional CODEX_SECURITY_SETUP_COMMAND protected variable for a non-interactive dependency setup step that runs before verification, isolated from OpenAI and GitLab credentials.
    • Adds draft merge-request publishing via CODEX_SECURITY_CREATE_MR=true, backed by a GITLAB_REMEDIATION_TOKEN (Developer role, api + write_repository scopes, scoped to the codex-security/publish environment).
    • Produces five named artifacts per scan job: scan-manifest.json, findings.json, coverage.json, results.sarif, and scan-exit-code.txt, with artifacts.access: maintainer to restrict exposure of vulnerable source snippets.
    • Supports three scan profiles selected automatically by trigger: protected same-project MR (standard/low, diff only), opt-in default-branch push or manual (standard/high, full repo), and opt-in scheduled deep scan (deep/xhigh, full repo).

    9 details in Everything

11. docs update Aug 30, 2026 · issue 059

    OpenAI Codex Security ships a GitLab CI template with diff, full, and deep scan modes plus automated remediation.

    └──▷ USE IT
    Trigger a scheduled nightly deep scan of the default branch with explicit time and cost budgets.
    .gitlab-ci.yml copy

    CODEX_SECURITY_SCHEDULED_DEEP_SCAN: "true"
    CODEX_SECURITY_DEEP_MAX_TIME_HOURS: "4"
    CODEX_SECURITY_DEEP_MAX_COST: "10"
    CODEX_SECURITY_ENABLE_REMEDIATION: "true"

    Enable full-repo scans on every push to the default branch and cap changed-file diff scans on MRs.
    .gitlab-ci.yml copy

    variables:
      CODEX_SECURITY_VERSION: "0.1.20"
      CODEX_SECURITY_FULL_SCAN_DEFAULT_BRANCH: "true"
      CODEX_SECURITY_MAX_CHANGED_FILES: "8"

    • Adds CODEX_SECURITY_VERSION CI variable (default 0.1.20) to pin the @openai/codex-security npm package version used in the pipeline.
    • Adds CODEX_SECURITY_FULL_SCAN_DEFAULT_BRANCH CI variable — set to true to run a full repository scan in standard mode at high effort on every push to the default branch.
    • Adds CODEX_SECURITY_SCHEDULED_DEEP_SCAN CI variable — set to true to trigger a scheduled deep scan of the full repository at xhigh effort.
    • Adds CODEX_SECURITY_DEEP_MAX_TIME_HOURS and CODEX_SECURITY_DEEP_MAX_COST CI variables to bound time (must be > 0 and < 8) and API cost for deep scans.
    • Adds CODEX_SECURITY_ENABLE_REMEDIATION CI variable — set to true to activate the codex-security-remediate job, which auto-generates fix patches for critical/high findings after full or deep scans.

    +8 more show less

    • Adds CODEX_SECURITY_REMEDIATION_EFFORT variable (default high) to control the effort level of the automated remediation job.
    • Introduces four pipeline stages — security_scan, security_remediation, security_publish, and security_gate — scoped to the codex-security GitLab CI template.
    • The codex-security scan job supports three scan targets via CODEX_SECURITY_TARGET: diff (MR-scoped, standard/low effort), repository in standard mode, and repository in deep mode.
    • Exports scan results as SARIF 2.1.0SARIF 2.1.0A JSON-based file format, standardized by OASIS, for expressing static analysis results so that cyber tools from different vendors can share findings through a single, machine-readable schema. via the codex-security export subcommand with --export-format sarif, publishing them to GitLab's native SARIFSARIFStatic Analysis Results Interchange Format, a standard for sharing code-analysis findings, including locations and rule details. It lets scanners report results to a common review interface. security report surface (reports: sarif: codex-security-artifacts/results.sarif).
    • Scan artifacts — including codex-security.json, results.sarif, and scan-manifest.json — are stored under codex-security-artifacts/ and retained for 7 days, accessible to maintainers.
    • Runs the codex-security CLI inside an isolated environment using unshare -Ur user namespaces and a sanitised env -i invocation, stripping OPENAI_API_KEY, CODEX_API_KEY, CODEX_ACCESS_TOKEN, CODEX_SECURITY_API_KEY, and GITLAB_REMEDIATION_TOKEN from the job environment before scanning.
    • Authenticates to the OpenAI API via --auth api-key using the CODEX_SECURITY_API_KEY CI/CD variable, surfaced as OPENAI_API_KEY only within the sandboxed scan process.
    • Supports partial-coverage scans: exit code 2 with scan-manifest.json status completed and coverage.json completeness partial is treated as a valid publishable result rather than a pipeline failure.

    13 details in Everything

12. docs update Aug 30, 2026 · issue 059

    OpenAI Codex Security gains a full GitLab CI/CD integration with SARIFSARIFStatic Analysis Results Interchange Format, a standard for sharing code-analysis findings, including locations and rule details. It lets scanners report results to a common review interface. publishing, policy gating, and verified auto-remediation via draft MRs.

    └──▷ TRY IT
    Run a diff-scoped security scan on a protected merge request and export results as SARIF for GitLab ingestion.
    copy

    $ OPENAI_API_KEY="$CODEX_SECURITY_API_KEY" \
      /tmp/codex-security-cli/node_modules/.bin/codex-security scan . \
      --diff "$(git merge-base "$CI_MERGE_REQUEST_DIFF_BASE_SHA" "$CI_COMMIT_SHA")" \
      --head "$CI_COMMIT_SHA" \
      --auth api-key \
      --output-dir /tmp/codex-security-results \
      --json
    
    /tmp/codex-security-cli/node_modules/.bin/codex-security export /tmp/codex-security-results \
      --export-format sarif \
      --source-root "$CI_PROJECT_DIR" \
      --output codex-security-artifacts/results.sarif

    Enable scheduled deep scans and opt-in full-repository scans on the default branch by setting these protected CI/CD variables.
    .gitlab-ci.yml copy

    CODEX_SECURITY_FULL_SCAN_DEFAULT_BRANCH: "true"
    CODEX_SECURITY_SCHEDULED_DEEP_SCAN: "true"

    Enable verified auto-remediation with a regression test and draft MR publishing after confirming scan findings look correct.
    .gitlab-ci.yml copy

    CODEX_SECURITY_ENABLE_REMEDIATION: "true"
    CODEX_SECURITY_VERIFICATION_COMMAND: "pytest tests/test_auth_invariant.py"
    CODEX_SECURITY_SETUP_COMMAND: "pip install -r requirements.txt"
    CODEX_SECURITY_CREATE_MR: "true"
    CODEX_SECURITY_MR_TEST_COMMAND: "pytest tests/test_auth_invariant.py"

    • Adds a GitLab CI/CD pipeline integration for @openai/codex-security (pinned to 0.1.20) that scans committed diffs on protected merge requests and publishes SARIF 2.1.0SARIF 2.1.0A JSON-based file format, standardized by OASIS, for expressing static analysis results so that cyber tools from different vendors can share findings through a single, machine-readable schema. findings to the GitLab Security tab.
    • Introduces the CODEX_SECURITY_API_KEY CI/CD variable (masked, hidden, protected, scoped to the codex-security/openai environment) to supply the OpenAI API key to the scan job.
    • Adds --diff <base-revision>, --head <commit-sha>, --auth api-key, --output-dir <dir>, and --json flags to the codex-security scan subcommand for diff-scoped scanning.
    • Adds the codex-security export subcommand with --export-format sarif, --source-root, and --output flags to produce a SARIF 2.1.0 report from raw scan results.
    • Introduces a two-stage scan-then-gate pattern: the codex-security report job publishes SARIF artifacts (exit codes 0, 1, and conditionally 2) and a separate codex-security-gate job restores the scanner exit code to enforce policy without blocking SARIF ingestion.

    +9 more show less

    • Adds CODEX_SECURITY_FULL_SCAN_DEFAULT_BRANCH=true variable to opt in to full-repository scans on protected default-branch pushes and manual pipelines.
    • Adds CODEX_SECURITY_SCHEDULED_DEEP_SCAN=true variable to enable scheduled deep scans (mode: deep, effort: xhigh) on the protected default branch.
    • Adds CODEX_SECURITY_ENABLE_REMEDIATION=true variable to enable automated verified remediation, restricted to protected default-branch pipelines.
    • Adds CODEX_SECURITY_VERIFICATION_COMMAND variable to specify the regression test command (exits 1 before fix, 0 after) used by the verify-fix step, which returns fixed, still_vulnerable, or inconclusive.
    • Adds optional CODEX_SECURITY_SETUP_COMMAND variable for a non-interactive dependency setup command executed before verification.
    • Introduces a validate, patch, and verify-fix command flow for remediation; repository-controlled setup and test commands run as a separate unprivileged user with only PATH, HOME, LANG, CI, and CI_PROJECT_DIR in their environment.
    • Adds CODEX_SECURITY_CREATE_MR=true variable and GITLAB_REMEDIATION_TOKEN (a protected, masked, hidden GitLab project access tokenaccess tokenA credential that authorizes a client to use a service or API. It usually has limited permissions and a lifetime; anyone holding it may be able to use those permissions. with api and write_repository scopes, scoped to the codex-security/publish environment) to publish verified patches as draft merge requests.
    • Adds CODEX_SECURITY_MR_TEST_COMMAND variable (kept unprotected) to specify the per-project security regression test that every generated remediation branch must pass before a draft MR is opened.
    • Scan artifacts include scan-manifest.json, findings.json, coverage.json, results.sarif, and scan-exit-code.txt, with artifact access restricted to the Maintainer role and a 7-day expiry.

    14 details in Everything

13. docs update Aug 30, 2026 · issue 059

    Codex Security preserves scan results across repo changes, carries forward false-positive decisions, and handles nested Git repos.

    • Keeps completed findings and reports tied to the original revision or working-tree snapshot when files or the repository revision change mid-scan.
    • Shows a completion warning when selected code changes or the target becomes unavailable, instead of discarding scan results.
    • Archives an existing scan before reusing its output directory for another scan.
    • Records a reason when closing a finding as a false positive, and carries reviewed false-positive decisions forward into later scans of the same target without applying them to unrelated checkouts or targets.
    • Suppresses a recurring finding only when the earlier false-positive reason still applies to the current code and security controls.

    +9 more show less

    • Keeps valid findings when another finding, report, or hardening artifact is malformed, and shows a warning for skipped data instead of discarding everything.
    • Removes duplicate findings and retains the strongest finding ranked by severity, confidence, and supporting evidence.
    • Marks coverage as partial when Codex cannot verify findings, review receipts, or follow-up areas.
    • Includes incomplete coverage and deferred-review warnings in SARIFSARIFStatic Analysis Results Interchange Format, a standard for sharing code-analysis findings, including locations and rule details. It lets scanners report results to a common review interface. exports.
    • Saves the selected model and reasoning effort with standard and deep scans so scan history and progress stay consistent across reloads.
    • Shows the count of active and completed independent deep-scan reviews and signals when result consolidation begins.
    • Adapts standard-scan discovery to available worker capacity while maintaining one in-scope file list and one candidate review pass.
    • Includes nested Git repositories when capturing a working-tree snapshot.
    • Preserves literal in-scope file paths and handles case-insensitive Windows paths.

    14 details in Everything

14. npm-v0.1.24 Aug 29, 2026 · release notes

    New serve subcommand and onDeepProgress callback for live deep scan tracking in Codex Security v0.1.24

    └──▷ GET THIS VERSION

    copy

    $ git clone --branch npm-v0.1.24 https://github.com/openai/codex-security.git
    # already have the repo? check out this version:
    $ git checkout npm-v0.1.24

    └──▷ TRY IT
    Run the local preview findings service on a random free port to avoid port conflicts during CI or development.
    copy

    $ codex-security serve --port 0

    Observe the number of completed and active independent-review items during a deep scan without blocking execution by providing the progress callback.
    javascript copy

    const scan = codex.scan({
      onDeepProgress: ({ completed, active, maximum }) => {
        console.log(`Progress: ${completed}/${active} / max ${maximum}`);
      }
    });

    • Adds the codex-security serve [--port PORT] CLI subcommand to start a preview findings service directly without Docker, with port 0 selecting a free random port.
    • Adds an optional onDeepProgress({ completed, active, maximum }) callback to the SDK scan options for observing durable Deep Scan progress counts independently of the main scan loop.

    2 details in Everything

15. npm-v0.1.23 Aug 28, 2026 · release notes

    OpenAI Codex Security v0.1.23 adds findings service publishing, deduplication CLI, and read-only dashboard

    └──▷ GET THIS VERSION

    copy

    $ git clone --branch npm-v0.1.23 https://github.com/openai/codex-security.git
    # already have the repo? check out this version:
    $ git checkout npm-v0.1.23

    └──▷ USE IT
    Publish a completed scan to a custom findings service while previewing the payload locally.
    shell copy

    codex-security publish scan --to custom --scan SCAN_ID --findings-url URL --dry-run

    Review potential duplicate findings within the scanned repository's scope using workflow recovery.
    shell copy

    codex-security dedupe --scan SCAN_ID --findings-url URL --workflow-id <id>

    • Adds publish scan --to custom subcommand with --scan, --findings-url, and --dry-run flags for publishing completed scans to a custom findings service.
    • Adds dedupe --scan subcommand with --findings-url, --all-repositories, and --workflow-id options for reviewing duplicate findings via CLI or SDK.
    • Enables browsing stored findings and duplicate groups through the service's read-only /dashboard endpoint with search, repository filters, sorting, and record details.

    3 details in Everything

16. npm-v0.1.21 Aug 27, 2026 · release notes

    OpenAI Codex Security v0.1.21 adds --assess-patch-risk for advisory assessments, GitHub code scanning alert imports, and CSV cloud publishing.

    └──▷ GET THIS VERSION

    copy

    $ git clone --branch npm-v0.1.21 https://github.com/openai/codex-security.git
    # already have the repo? check out this version:
    $ git checkout npm-v0.1.21

    └──▷ USE IT
    Assess the risk of a completed patch and create a draft PR with the summary
    shell copy

    codex patch --assess-patch-risk --create-pr

    Preview publishing findings from a CSV file without sending data or signing in
    shell copy

    codex publish scan --to cloud --csv findings.csv --dry-run

    • Adds the patch --assess-patch-risk subcommand with optional --create-pr to request advisory risk assessments on completed patches
    • Adds support for importing GitHub code scanning alerts through the CLI or SDK for validation against a local checkout, preserving upstream alert context
    • Adds publish scan --to cloud --csv PATH to publish findings from CSV files, with --dry-run support to preview uploads without signing in or sending data

    3 details in Everything

    └──▷ BREAKING ON UPGRADE

    • !Credential-home locks now follow the owning process's lifetime; finish operations using older versions before upgrading
    • !Custom executables selected with CODEX_CLI_PATH need thread-source attribution support for both exec and app-server due to the Codex runtime update to 0.149.1
17. npm-v0.1.20 Aug 25, 2026 · release notes

    Adds --check-linear-access logic to publish command and skips already recorded Linear issues.

    └──▷ GET THIS VERSION

    copy

    $ git clone --branch npm-v0.1.20 https://github.com/openai/codex-security.git
    # already have the repo? check out this version:
    $ git checkout npm-v0.1.20

18. npm-v0.1.19 Aug 25, 2026 · release notes

    Adds publish scan --to cloud CLI subcommand for uploading scans to Codex Security Cloud and Linear integration.

    └──▷ GET THIS VERSION

    copy

    $ git clone --branch npm-v0.1.19 https://github.com/openai/codex-security.git
    # already have the repo? check out this version:
    $ git checkout npm-v0.1.19

    • Publishes one or more completed scans to Codex Security Cloud using the new --to cloud argument on the publish scan command
    • Supports --dry-run flag with publish scan --to cloud to validate and preview findings without uploading
    • Enables selection of saved scans for publication by scan ID, unique ID prefix, or latest keyword

    3 details in Everything

19. npm-v0.1.18 Aug 23, 2026 · release notes

    Adds --safety-identifier CLI flag and SDK option to attribute API-key scans to end users

    └──▷ GET THIS VERSION

    copy

    $ git clone --branch npm-v0.1.18 https://github.com/openai/codex-security.git
    # already have the repo? check out this version:
    $ git checkout npm-v0.1.18

    └──▷ USE IT
    Run a scan with an end-user identifier to attribute results.
    shell copy

    codex-security scan --safety-identifier user_12345

    Configure the SDK client with a safety identifier for attribution.
    code copy

    client.scan({ safetyIdentifier: 'user_12345' })

    • Adds safetyIdentifier option to the SDK for scan attribution
    • Preserves accepted findings and partial artifacts when Deep Scan fails, is canceled, or is interrupted

    2 details in Everything

20. npm-v0.1.17 Aug 23, 2026 · release notes

    OpenAI Codex Security v0.1.17 adds component scans, custom validation workflows, and finding re-checking

    └──▷ GET THIS VERSION

    copy

    $ git clone --branch npm-v0.1.17 https://github.com/openai/codex-security.git
    # already have the repo? check out this version:
    $ git checkout npm-v0.1.17

    • Adds component scans to split large repositories into explicit or planned components, scan each one independently, and produce a combined coverage report.
    • Adds custom validation setup, test, and cleanup steps for standard and diff scans via custom-validation workflows.
    • Adds the ability to recheck a saved finding without starting another scan via finding validation.

    3 details in Everything

21. docs update Aug 22, 2026 · issue 053

    Codex Security deep scans gain configurable --max-time-hours deadline and persistent max_time_hours config key

    └──▷ TRY IT
    Cap a deep scan at 1.5 hours so CI pipelines get a partial-but-timely report instead of waiting up to four days.
    copy

    $ codex-security scan --mode deep --max-time-hours 1.5

    Set a persistent deadline for all deep scans run from a shared config, useful for bulk campaign scheduling.
    ini copy

    [deep_scan]
    max_time_hours = 1.5

    • Adds --max-time-hours flag to --mode deep scans to set a worker deadline (default 96 hours, accepts any positive value up to 96 including fractions); at the deadline, finished worker results are aggregated into the final report and unfinished workers are stopped.
    • Adds max_time_hours key under [deep_scan] in the deep-scan configuration file for persistent deadline settings or bulk campaigns.

    2 details in Everything

22. docs update Aug 22, 2026 · issue 053

    Codex Security CLI gains Linear issue publishing, automated patching with PR creation, and deep-scan concurrency controls

    └──▷ TRY IT
    Publish all findings from a completed scan to a specific Linear team and project using a personal API key, assigning each issue to a teammate.
    copy

    $ CODEX_SECURITY_LINEAR_API_KEY=YOUR_LINEAR_PERSONAL_API_KEY codex-security publish scan /path/to/completed-scan --to linear --linear-team TEAM_ID --project PROJECT_ID --linear-assignee teammate@example.com

    After a full scan, automatically patch high-and-above findings and open a GitHub pull request with the verified fixes.
    copy

    $ codex-security scan --patch --patch-severity high --create-pr

    Run a deep scan with bounded concurrency: two workers, up to ten discovery runs, stopping workers after 1.5 hours.
    copy

    $ codex-security scan --max-discovery-runs 10 --max-time-hours 1.5

    • New codex-security publish scan subcommand publishes completed scan findings to Linear, with flags --to linear, --linear-team TEAM_ID, --project PROJECT_ID, --linear-api-key KEY, --linear-assignee EMAIL_OR_USER_ID, --dry-run, and --json.
    • Supports env vars CODEX_SECURITY_LINEAR_TEAM, CODEX_SECURITY_LINEAR_PROJECT, and CODEX_SECURITY_LINEAR_API_KEY as alternatives to the matching CLI flags for Linear publishing.
    • New --patch flag on scan triggers automated fix-and-verify of findings after a complete scan (requires CLI 0.1.15 or later); --patch-severity {critical,high,medium,low} sets the minimum severity threshold (default: high).
    • New --create-pr flag commits verified patch files and opens a GitHub pull request via the GitHub CLI; if the push fails, patch --resume-pr BRANCH retries from the same repository.
    • New --max-discovery-runs N flag caps total independent standard-scan worker runs (default: 40) for deep scans.

    +6 more show less

    • New --max-time-hours HOURS flag sets a worker execution time limit in hours (default: 96; accepts fractions up to 96) for deep scans; on expiry, completed results are preserved and aggregated into the final report.
    • New --linear-issue flag (repeatable) imports Linear issues by ID or URL for patching; --linear-project selects a project's open issues and --linear-filter accepts a JSON filter to narrow selection.
    • Config key max_time_hours and stop_after_consecutive_errors are available in the TOML config file for deep-scan tuning; stop_after_consecutive_errors is only settable via TOML.
    • Scan session logs (including worker events) are now readable in full via the CLI; logs are noted as unredacted and may contain source code or credentials.
    • Documents that codex_security_scan filesystem profile sets approvalPolicy to "never", meaning scans never pause for interactive approval; settings like approval_policy and sandbox_mode supplied via CLI or SDK codexOverrides cannot override these scan controls.
    • CLI now requires Node.js 22 (22.13.0 or later), 24, or 26; Python 3.10 or later is required for scans, bulk scans, exports, scan history, and saved findings.

    11 details in Everything

23. docs update Aug 22, 2026 · issue 053

    Codex Security CLI gains --patch, --patch-severity, --create-pr, and --max-time-hours flags for automated patching and scan time control.

    └──▷ TRY IT
    Automatically patch all high and critical findings and open a GitHub PR — useful in CI to remediate without manual review.
    copy

    $ codex-security scan --patch --patch-severity high,critical --create-pr

    Cap a deep scan at 1.5 hours so it fits inside a CI window, preserving completed worker results even if some workers are cut short.
    copy

    $ codex-security scan --max-time-hours 1.5

    Check the installed package version and its bundled plugin version before running a scan.
    copy

    $ codex-security info

    • Adds --patch flag to automatically patch high and critical findings without the interactive finding browser.
    • Adds --patch-severity flag to control which severity levels are patched non-interactively.
    • Adds --create-pr flag to commit verified patches and open a GitHub pull request directly from the CLI.
    • Adds --max-time-hours flag (accepts a positive number up to 96, including fractional hours) to cap scan duration; at the limit, unfinished workers are stopped, completed results are preserved, and a final aggregated report is produced.
    • Adds interactive finding browser after a complete scan, letting practitioners review evidence and select findings to fix; saved tasks appear in the Codex desktop app.

    +3 more show less

    • Supports patching saved findings and importing Linear issues via the validate patch reference workflow.
    • Requires Node.js 22 (22.13.0 or later), 24, or 26; scans, bulk scans, exports, scan history, and saved findings additionally require Python 3.10 or later.
    • Adds info subcommand to display both the package version and the version of its bundled plugin.

    8 details in Everything

24. docs update Aug 22, 2026 · issue 053

    Codex Security plugin 0.1.20 adds full end-to-end deep scan audits, Trusted Access checks, and broader environment support; 0.1.19 adds [deep_scan].max_time_hours.

    └──▷ TRY IT
    Check which package and bundled plugin versions are active in your current installation before relying on a new deep-scan feature.
    copy

    $ npx @openai/codex-security info --json

    Cap a deep scan at 4.5 hours so it fits inside a CI window while still preserving any discovery work completed before the deadline.
    ini copy

    [deep_scan]
    max_time_hours = 4.5

    • Adds [deep_scan].max_time_hours config key (0.1.19) to cap deep scan duration at up to 96 hours (fractional hours supported); completed discovery results are preserved when the deadline expires, and the report is marked partial if no source review finishes in time.
    • Run npx @openai/codex-security info --json to inspect both the package and bundled plugin versions together.
    • Deep scan workers now run through the same end-to-end audit pipeline as standard scans — threat modeling, validation, attack-path analysis, and coverage reporting — with results combined into a single scan.
    • Deep scans default to four concurrent workers, stop after four consecutive completed scans add no new findings, and cap at 40 worker runs total; existing workers = "auto" settings now resolve to four workers.
    • Deep scan workers that finished source review but lost their final draft are resumed rather than restarted from scratch.

    +5 more show less

    • Checks Trusted Access for Cyber status in Codex hosts that expose the Codex Security Access app before standard, change, and deep scans begin; shows a prominent warning with an enrollment link when access is not granted, but does not block the scan.
    • Deep scan workers can now be launched from packaged CLI and SDK installations, including Windows installations without a global codex executable.
    • Standalone CLI and SDK deep scan settings are kept isolated from other running instances, and non-interactive approval settings are preserved in nested deep scan workers.
    • Recovers valid findings from older or incomplete scan data and completes scans when independent coverage reports overlap (0.1.20).
    • Passes OpenRouterOpenRouterA unified API gateway that routes requests to dozens of LLM providers under one endpoint, letting cyber tools swap or compare models without rewriting provider-specific integration code. and Fireworks credentials through to deep-scan workers (0.1.19).

    10 details in Everything

25. docs update Aug 22, 2026 · issue 053

    Codex Security deep scans gain max_time_hours config key (up to 96 h) and new worker-control settings in plugin v0.1.19

    └──▷ USE IT
    Bound a long-running deep scan to 12 hours so overnight jobs don't run indefinitely, while tolerating up to 40 consecutive worker errors before aborting.
    ini copy

    max_time_hours = 12
    stop_after_consecutive_errors = 40

    • Adds max_time_hours config key (plugin v0.1.19+) to cap deep-scan worker execution at a positive number of hours up to 96, with fractional values supported; expired workers are stopped and completed results are aggregated into the final report.
    • Exposes configurable limits for the number of independent standard-scan runs allowed before aggregation, the number of parallel standard-scan workers (default 4), and the number of subagents each worker may start (default 4).
    • Adds a 'stop after consecutive completed worker scans produce no new findings' threshold to avoid redundant deep-scan work.

    3 details in Everything

26. npm-v0.1.16 Aug 20, 2026 · release notes

    Adds verify-fix subcommand for read-only security analysis in OpenAI Codex Security.

    └──▷ GET THIS VERSION

    copy

    $ git clone --branch npm-v0.1.16 https://github.com/openai/codex-security.git
    # already have the repo? check out this version:
    $ git checkout npm-v0.1.16

    └──▷ TRY IT
    Check potential fixes for correctness and security impact without modifying the codebase.
    copy

    $ codex-security verify-fix <target>

27. npm-v0.1.15 Aug 19, 2026 · release notes

    OpenAI Codex Security v0.1.15 adds interactive finding review, patching, and Linear issue integration

    └──▷ GET THIS VERSION

    copy

    $ git clone --branch npm-v0.1.15 https://github.com/openai/codex-security.git
    # already have the repo? check out this version:
    $ git checkout npm-v0.1.15

    • codex security findings now supports an interactive mode for reviewing, patching vulnerabilities, and optionally creating pull requests.
    • Live scan session details are now surfaced directly in the Codex desktop application UI.

    2 details in Everything

28. npm-v0.1.13 Aug 16, 2026 · release notes

    Adds CLI integration to publish security scan findings directly to Linear via API or interactive presentation.

    └──▷ GET THIS VERSION

    copy

    $ git clone --branch npm-v0.1.13 https://github.com/openai/codex-security.git
    # already have the repo? check out this version:
    $ git checkout npm-v0.1.13

    └──▷ TRY IT
    Publish the latest scan results to your team's Linear project automatically.
    copy

    $ codex-security publish --to linear

    Assign specific issues to team members when publishing findings via API.
    copy

    $ codex-security publish --to linear --assignees '@alice' '@bob'

    • cli can now publish completed security scans to the connected Linear app
    • cli adds an interactive scan publication presentation for manual review
    • publish supports direct Linear API publication with assignee assignment

    3 details in Everything

29. npm-v0.1.12 Aug 15, 2026 · release notes

    New --max-reasoning-effort and --max-cost CLI flags for controlling scan resource usage

    └──▷ GET THIS VERSION

    copy

    $ git clone --branch npm-v0.1.12 https://github.com/openai/codex-security.git
    # already have the repo? check out this version:
    $ git checkout npm-v0.1.12

    └──▷ USE IT
    Run a scan with reduced reasoning effort to lower latency or cost.
    shell copy

    codex-security scan --max-reasoning-effort=low <path>

    Cap the total spend for a bulk scan operation across repositories.
    shell copy

    codex-security bulk-scan --max-cost 5.0 <path>

    • Adds --max-reasoning-effort=high CLI flag to set the reasoning level for scans
    • Adds --max-cost CLI argument to enforce a spending ceiling on CLI and bulk scans

    2 details in Everything

30. docs update Aug 14, 2026 · issue 045

    Codex Security CLI gains deep-scan concurrency controls, OpenRouterOpenRouterA unified API gateway that routes requests to dozens of LLM providers under one endpoint, letting cyber tools swap or compare models without rewriting provider-specific integration code./Fireworks provider support, scan prompt files, and enhanced log inspection commands.

    └──▷ TRY IT
    Run a deep scan with bounded concurrency to prevent resource exhaustion in CI, stopping early if no new issues are found.
    copy

    $ openai-codex-security scan --mode deep --workers 2 --subagents 3 --stop-after-no-new 3 --max-discovery-runs 10 --headless

    Set persistent deep-scan defaults so every scan in your environment respects concurrency limits without repeating flags.
    ~/.codex/codex-security/config.toml copy

    [deep_scan]
    workers = 2
    subagents = 3
    stop_after_no_new = 3
    max_discovery_runs = 10

    Use OpenRouter with Claude to run a focused scan guided by a custom prompt file and a post-scan follow-up.
    copy

    $ OPENROUTER_API_KEY="your-openrouter-api-key" openai-codex-security scan openrouter anthropic/claude-sonnet-4.5 --scan-prompt-file security-focus.md --post-scan-prompt-file follow-up.md

    • Adds --mode {standard,deep} flag to select between standard and deep scan modes.
    • Adds --workers N, --subagents N, --stop-after-no-new N, and --max-discovery-runs N flags to control deep-scan discovery concurrency and runtime; defaults are automatic workers, 3 subagents, stop after 6 consecutive empty runs, and 60 max discovery runs.
    • Adds persistent deep-scan defaults via [deep_scan] section in ~/.codex/codex-security/config.toml (or $CODEX_HOME/codex-security/config.toml) with keys workers, subagents, stop_after_no_new, and max_discovery_runs.
    • Supports OpenRouter as an alternative model provider: set OPENROUTER_API_KEY and pass openrouter with an explicit model name (e.g. anthropic/claude-sonnet-4.5).
    • Supports Fireworks as an alternative model provider: set FIREWORKS_API_KEY and pass fireworks with an explicit model name (e.g. accounts/fireworks/models/qwen3-235b-a22b).

    +13 more show less

    • Adds --scan-prompt-file FILE to supply a text or Markdown file of scan instructions, and --post-scan-prompt-file FILE to run follow-up instructions in the same authenticated session after successful or partially-covered scans.
    • Adds --headless flag to force plain-text progress output instead of the interactive scan dashboard in interactive terminals.
    • Adds --dry-run flag to validate repository, target, knowledge base, output directory, and Codex configuration without starting a scan or loading credentials.
    • Adds --knowledge-base PATH flag to share security documents across scanned repositories.
    • Adds --max-cost USD flag to cap scan spending; partial results remain on disk if the limit is reached.
    • Adds --model MODEL flag to explicitly select the model used for scanning.
    • Adds logs subcommand to read complete saved session events for a scan and its workers, with structured machine-formatted output.
    • Adds scans match subcommand to save finding matches explicitly between two scans.
    • Adds scan comparison capability to find new, persisting, reopened, resolved, and unknown findings between two scans, with automatic root-cause matching and reuse of saved matches.
    • Adds --show-linked-findings flag to include finding links from earlier scans when listing open findings.
    • Adds completed-scan summary output to stderr including open finding count, severity breakdown (critical, high, informational), coverage, elapsed time, report path (REPORT), token usage (TOKENS), estimated cost, and result directory (RESULTS).
    • Bulk-scan prompt CSV column adds repository-specific scan instructions appended after any shared --scan-prompt-file prompt, and mode column configures per-repository scan mode.
    • Requires Node.js 22.13.0 or later; running scans or exporting findings additionally requires Python 3.10 or later.

    18 details in Everything

31. docs update Aug 14, 2026 · issue 045

    Codex Security CLI gains GitLab CI/CD integration with SARIF 2.1.0SARIF 2.1.0A JSON-based file format, standardized by OASIS, for expressing static analysis results so that cyber tools from different vendors can share findings through a single, machine-readable schema. upload, diff-scoped MR scanning, and severity-threshold policy support.

    └──▷ TRY IT
    Scan only the committed changes in a GitLab merge request and upload a SARIFSARIFStatic Analysis Results Interchange Format, a standard for sharing code-analysis findings, including locations and rule details. It lets scanners report results to a common review interface. report for Security Dashboard review.
    copy

    $ CODEX_SECURITY_SCAN_SCOPE=diff
    OPENAI_API_KEY="$codex_security_api_key" \
      codex-security scan \
        --diff "$CI_MERGE_REQUEST_DIFF_BASE_SHA" \
        --head "$CI_COMMIT_SHA" \
        --json > /tmp/codex-security.json

    Enable a full default-branch scan in addition to MR diff scans by setting the opt-in variable at the project level.
    .gitlab-ci.yml copy

    variables:
      CODEX_SECURITY_FULL_SCAN_DEFAULT_BRANCH: "true"

    • Adds GitLab CI/CD pipeline integration via .gitlab-ci.yml, ingesting SARIF 2.1.0 reports on GitLab Ultimate 19.2 or later through artifacts:reports:sarif.
    • Adds CODEX_SECURITY_SCAN_SCOPE CI/CD variable controlling whether the job runs a diff scan (merge-request changes only) or a full scan of the default branch.
    • Adds CODEX_SECURITY_FULL_SCAN_DEFAULT_BRANCH variable (default "false") to opt into a complete default-branch scan in addition to merge-request diff scans.
    • Supports --diff <base_sha> --head <head_sha> flags on the scan command to scope analysis to committed PR/MR changes using CI_MERGE_REQUEST_DIFF_BASE_SHA and CI_COMMIT_SHA.
    • Supports --mode standard flag for full-repository scans on the default branch.

    +3 more show less

    • Supports --json flag to emit structured scan results to a file for downstream processing and artifact archiving.
    • Supports --source-root <path> flag on the export command to anchor SARIF source paths to the repository root.
    • Preserves scan artifacts on failure via artifacts: when: always, and restricts access to detailed results with artifacts:access: maintainer.

    8 details in Everything

32. docs update Aug 14, 2026 · issue 045

    Codex Security CLI bulk scans gain knowledge-base sharing, per-repo prompts, and OpenRouterOpenRouterA unified API gateway that routes requests to dozens of LLM providers under one endpoint, letting cyber tools swap or compare models without rewriting provider-specific integration code./Fireworks provider support.

    └──▷ TRY IT
    Attach architecture docs and a threat model to every scan in a bulk campaign so the model has shared security context.
    copy

    $ codex-security bulk-scan repos.csv --output-dir ./results --knowledge-base /path/to/architecture.md --knowledge-base /path/to/threat-model.md

    Run bulk scans with shared scan instructions and a follow-up prompt, using Fireworks as the inference provider.
    copy

    $ FIREWORKS_API_KEY=<key> codex-security bulk-scan repos.csv --output-dir ./results --provider fireworks --scan-prompt-file scan-instructions.md --post-scan-prompt-file follow-up.md

    • Adds --knowledge-base flag (repeatable) to inject architecture documents, threat models, or security policies into every scan in a bulk campaign.
    • Adds --scan-prompt-file flag to supply shared scan instructions prepended before each repository's CSV prompt field.
    • Adds --post-scan-prompt-file flag to run follow-up instructions in the same authenticated session after each successful scan or scan with incomplete coverage.
    • Adds --provider flag with support for OpenRouter and Fireworks as alternative inference providers, configured via OPENROUTER_API_KEY or FIREWORKS_API_KEY environment variables.
    • Campaign state is recorded in the output directory, enabling the CLI to resume unfinished repository scans and skip completed ones across interrupted runs.

    +1 more show less

    • Rejects campaigns where the repository inventory, revisions, scopes, scan modes, or prompt instructions differ from the pinned manifest, preventing silent scope drift on resume.

    6 details in Everything

33. docs update Aug 14, 2026 · issue 045

    Codex Security CLI gains headless mode, deep-scan controls, custom prompt files, scan comparison, and log inspection commands.

    └──▷ TRY IT
    Run a deep scan in CI without an interactive dashboard and cap discovery to 10 runs with 2 subagents.
    copy

    $ codex-security scan --headless --subagents 2 --max-discovery-runs 10 /path/to/repository

    Focus a scan on specific security priorities by supplying custom prompt files, with a follow-up for triage notes.
    copy

    $ codex-security scan --scan-prompt-file /path/to/scan.md --post-scan-prompt-file /path/to/follow-up.md /path/to/repository

    • Adds --headless flag to output plain progress lines instead of the live scan dashboard, useful for CI or non-interactive terminals.
    • Adds --subagents, --stop-after-no-new, and --max-discovery-runs flags to control discovery workers and scan termination in deep mode (repository and path targets only).
    • Adds --scan-prompt-file and --post-scan-prompt-file options to inject custom scan instructions and follow-up instructions from Markdown files; both also work with bulk scans via a prompt CSV column.
    • Adds logs subcommand to inspect saved events from a scan and its workers (note: saved logs are not redacted and may contain source code or credentials).
    • Adds scan comparison command to diff two scans and surface new, persisting, reopened, resolved, or unknown findings, with automatic root-cause matching.

    +3 more show less

    • Adds --provider flag to select a model provider such as OpenRouterOpenRouterA unified API gateway that routes requests to dozens of LLM providers under one endpoint, letting cyber tools swap or compare models without rewriting provider-specific integration code. or Fireworks, paired with the provider's API key.
    • Supports resuming interrupted bulk scans by re-running the same command; completed repositories are skipped automatically.
    • Requires Node.js 22.13.0 or later and Python 3.10 or later for scanning and exporting findings.

    8 details in Everything

34. docs update Aug 14, 2026 · issue 045

    Codex Security 0.1.18 adds Amazon Bedrock authentication support and raises scan initialization timeout from 30 s to 5 min.

    • Supports Amazon Bedrock as a scan backend, accepting bearer tokensbearer tokensA credential that grants access to whoever presents it, without a separate proof of possession. Protecting the token matters because a stolen copy can be used by someone else., AWS profiles, regional settings, web identity, and container credentials for authentication.
    • Passes AWS credentials through to delegated deep-scan workers so Bedrock auth remains available across the full scan pipeline.
    • Simplifies the workflow for standard repository and scoped-path scans while preserving nested guidance, exact scan scope, progress updates, and final scan reports.
    • Extends the initialization window for prompt-started scans from 30 seconds to five minutes, preventing timeouts on large repositories.
    • Completes standard and deep scans on hosts that enforce tool-name length limits.

    5 details in Everything

35. npm-v0.1.11 Aug 13, 2026 · release notes

    Add configurable graceful time limits for deep scans

    └──▷ GET THIS VERSION

    copy

    $ git clone --branch npm-v0.1.11 https://github.com/openai/codex-security.git
    # already have the repo? check out this version:
    $ git checkout npm-v0.1.11

36. npm-v0.1.10 Aug 12, 2026 · release notes

    New codex scan inspect subcommand to view saved scan and worker logs.

    └──▷ GET THIS VERSION

    copy

    $ git clone --branch npm-v0.1.10 https://github.com/openai/codex-security.git
    # already have the repo? check out this version:
    $ git checkout npm-v0.1.10

    └──▷ HOW TO FIND IT
    Inspect the logs for a previous scan run without re-executing the scan.
    📍codex scan inspect <scan-id>
37. npm-v0.1.9 Aug 11, 2026 · release notes

    Codex Security v0.1.9 removes CLI/config limits and enables bulk-scan with flexible CSV ordering.

    └──▷ GET THIS VERSION

    copy

    $ git clone --branch npm-v0.1.9 https://github.com/openai/codex-security.git
    # already have the repo? check out this version:
    $ git checkout npm-v0.1.9

    • Removes session event, preflight configuration, CLI input/output, configuration, scan report, and schema limits allowing unlimited length inputs and outputs

    1 detail in Everything

38. npm-v0.1.8 Aug 7, 2026 · release notes

    Adds --custom-scan-prompts and follow-up prompt support for tailored scanning behavior.

    └──▷ GET THIS VERSION

    copy

    $ git clone --branch npm-v0.1.8 https://github.com/openai/codex-security.git
    # already have the repo? check out this version:
    $ git checkout npm-v0.1.8

    └──▷ TRY IT
    Provide specific instructions to the scanner at the start of an engagement.
    copy

    $ codex-security scan --custom-scan-prompts 'Focus on API endpoints'

    Guide the scanner's deeper investigation after initial analysis.
    copy

    $ codex-security scan --follow-up-prompt 'Check for privilege escalation paths'

    • Adds --custom-scan-prompts flag to specify custom scan prompts
    • Adds support for follow-up prompts during a scan session

    2 details in Everything

39. npm-v0.1.7 Aug 7, 2026 · release notes

    Adds Amazon Bedrock authentication support for scans

    └──▷ GET THIS VERSION

    copy

    $ git clone --branch npm-v0.1.7 https://github.com/openai/codex-security.git
    # already have the repo? check out this version:
    $ git checkout npm-v0.1.7

    • Enables scanning with Amazon Bedrock authentication

    1 detail in Everything

40. npm-v0.1.6 Aug 7, 2026 · release notes

    OpenAI Codex Security npm-v0.1.6 adds OpenRouterOpenRouterA unified API gateway that routes requests to dozens of LLM providers under one endpoint, letting cyber tools swap or compare models without rewriting provider-specific integration code. and Fireworks inference providers, deep scan controls, and verbose diagnostics.

    └──▷ GET THIS VERSION

    copy

    $ git clone --branch npm-v0.1.6 https://github.com/openai/codex-security.git
    # already have the repo? check out this version:
    $ git checkout npm-v0.1.6

    • --inferencer flag now accepts openrouter and fireworks to route scanning LLMLLMA large language model, a neural network trained on large amounts of text to recognize patterns and generate language. Applications use it for tasks such as answering, summarizing and writing code. calls through third-party inference providers.

    1 detail in Everything

41. npm-v0.1.5 Jul 31, 2026 · release notes

    Adds automatic scan comparison matching and nested Git repository support.

    └──▷ GET THIS VERSION

    copy

    $ git clone --branch npm-v0.1.5 https://github.com/openai/codex-security.git
    # already have the repo? check out this version:
    $ git checkout npm-v0.1.5

    • Automatically match scan comparisons

    1 detail in Everything

42. npm-v0.1.2 Jul 31, 2026 · release notes

    Adds reasoning effort controls to the security CLI

    └──▷ GET THIS VERSION

    copy

    $ git clone --branch npm-v0.1.2 https://github.com/openai/codex-security.git
    # already have the repo? check out this version:
    $ git checkout npm-v0.1.2

43. npm-v0.1.0 Jul 31, 2026 · release notes

    First release of OpenAI Codex Security as an npm package with public TypeScript SDK and Node workflows.

    └──▷ GET THIS VERSION

    copy

    $ git clone --branch npm-v0.1.0 https://github.com/openai/codex-security.git
    # already have the repo? check out this version:
    $ git checkout npm-v0.1.0

    • Bootstraps the public TypeScript SDK for programmatic integration
    • Enables Node.js workflows via a new npm distribution

    2 details in Everything