diff --git a/README.md b/README.md index f7ed813a..8a4a7190 100644 --- a/README.md +++ b/README.md @@ -5,461 +5,226 @@ **Security guardrails for AI-built apps.** -AppGuardrail was formerly developed as VibeSec. The rename avoids the occupied third-party PyPI `vibesec` namespace. +AppGuardrail helps teams catch common security failures introduced during AI-assisted development, turn findings into reviewable fixes, and keep those checks running as the application changes. -AppGuardrail helps builders using Cursor, Claude Code, Lovable, Replit, Bolt, Supabase, Firebase, Vercel, and Netlify find and fix security issues introduced during AI-assisted development. +It is designed for builders working with AI coding tools and modern application stacks—not as a replacement for application authorization, threat modeling, penetration testing, incident response, or production security ownership. -> **AI 생성 앱을 위한 보안 가드레일.** -> AppGuardrail은 Cursor, Claude Code, Lovable, Replit, Bolt, Supabase, Firebase, Vercel, Netlify로 만든 앱에서 자주 발생하는 보안 문제를 찾고 고칠 수 있게 돕습니다. +## Why AppGuardrail ---- +AI-assisted development can ship useful software quickly, but it also makes it easy to repeat security mistakes at scale: missing ownership checks, exposed credentials, permissive CORS or storage rules, unsigned webhooks, unsafe file handling, and temporary code that quietly becomes production code. -## What is AppGuardrail? +AppGuardrail makes that work repeatable across five connected surfaces: -AppGuardrail is a **persistent security layer for AI-assisted builders** — not a one-time pentest, but a security co-pilot that stays with you through the entire lifecycle of your AI-built app: coding, deployment, operation, updates, and incident response. +| Surface | What it does | +| --- | --- | +| **Rules** | Installs security guidance for supported AI coding assistants and project workflows. | +| **Scan** | Finds secrets, authorization gaps, risky configuration, packaged rule matches, and supported external-scanner findings. | +| **Review** | Produces human-readable security review guidance and AI-ready review prompts. | +| **Monitor** | Installs continuous GitHub Actions checks and emits normalized findings/SARIF. | +| **Fix** | Provides bounded remediation prompts, safe deterministic fixes, and re-verification steps. | -> AppGuardrail = AI 앱 빌더의 미니 보안팀 - ---- - -## What AppGuardrail Provides - -| Layer | Description | -|---|---| -| 🛡️ **AppGuardrail Rules** | Security rules for AI coding assistants (Cursor, Claude Code, Windsurf, Lovable) | -| 🔍 **AppGuardrail Scan** | Lightweight static analysis for secrets, auth gaps, misconfigurations, and packaged YAML regex rules | -| 👁️ **AppGuardrail Review** | Human-readable review templates and AI-powered audit prompts | -| 📡 **AppGuardrail Monitor** | GitHub Actions workflow installer for continuous AppGuardrail checks | -| 🔧 **AppGuardrail Fix** | AI-ready fix prompts + patch guidance + re-verification steps | - ---- - -## Quick Start - -### Run the CLI +## Quick start Requires Python 3.11 or newer. -Install from PyPI: - ```bash python3 -m pip install appguardrail -appguardrail --help -``` -Maintainers can prepare PyPI releases with GitHub Actions Bot and OpenCode -Agent. See [Release Automation](docs/release-automation.md). +# Add guardrails to the current project. +appguardrail init -For the productization roadmap, see the -[2B KRW sale readiness plan](docs/product/2026-07-02-2b-krw-sale-readiness-plan.md). +# Scan the repository. +appguardrail scan . +``` -### Initialize security rules in your project +Initialize one supported tool explicitly when you do not want the default set: ```bash -# Recommended: install guardrails for Codex, Copilot, Claude Code, Cursor, and Windsurf -appguardrail init - -# Or install for one tool explicitly appguardrail init --tool cursor appguardrail init --tool claude-code appguardrail init --tool codex appguardrail init --tool copilot appguardrail init --tool lovable +``` -# For a Next.js + Supabase stack +Stack-aware initialization is also available: + +```bash appguardrail init --stack nextjs-supabase ``` -This creates: -- `.cursor/rules/appguardrail.md` -- `.windsurf/rules/appguardrail.md` -- `CLAUDE.md` -- `AGENTS.md` -- `.github/copilot-instructions.md` -- `APPGUARDRAIL_CHECKLIST.md` - -`appguardrail init --tool lovable` creates `LOVABLE_SECURITY_CHECKLIST.md`. +## Scan, review, fix -### Scan your codebase +Run the built-in scanner directly: ```bash appguardrail scan . +``` -# Also run Trivy FS for dependency CVEs, secrets, and IaC misconfigurations -appguardrail scan --trivy . - -# The scanner detects Python, Java, JavaScript, TypeScript, and web files -# automatically. If supported external SAST tools are installed and runnable, -# scan auto mode can include Bandit/Ruff/Semgrep without choosing a language profile. - -# Run OWASP ZAP baseline only when you have an authorized running URL -APPGUARDRAIL_TARGET_URL=https://your-authorized-test-host.example appguardrail scan . +Useful output and optional analysis paths include: -# If CodeGraph is installed, prepare structural context for deeper review -appguardrail scan --codegraph . - -# Save normalized findings for report generation or dashboard ingestion +```bash +# Normalized findings for reports or dashboard ingestion. appguardrail scan --findings-json reports/findings.json . -# Emit SARIF 2.1.0 for GitHub code scanning, VS Code, and other tools +# SARIF 2.1.0 for GitHub code scanning and other SARIF consumers. appguardrail scan --sarif appguardrail.sarif . -``` -The SARIF output feeds GitHub code scanning -(`github/codeql-action/upload-sarif`), the VS Code SARIF viewer, and any other -SARIF consumer — findings appear in the GitHub **Security** tab and as inline PR -annotations, ranked by `security-severity`. `appguardrail monitor` installs a -workflow that emits and uploads SARIF automatically while preserving the deploy -gate. Set the `APPGUARDRAIL_CONTROL_PLANE_URL` and `APPGUARDRAIL_API_KEY` -repository secrets and that workflow also pushes every scan to your control -plane for history and drift tracking. - -Detects: -- Hardcoded secrets (`SUPABASE_SERVICE_ROLE_KEY`, `STRIPE_SECRET_KEY`, etc.) -- Hardcoded provider API tokens by distinctive prefix: OpenAI/Anthropic (`sk-`, `sk-ant-`), AWS (`AKIA`/`ASIA`), GitHub (`ghp_`/`github_pat_`), Google (`AIza`), Slack (`xoxb-…` tokens and `hooks.slack.com` webhooks), Twilio (`AC…`/`SK…`), SendGrid (`SG.…`), npm (`npm_…`), and PyPI (`pypi-AgEIcHlwaS…`) -- Trivy-backed dependency vulnerabilities, secrets, and misconfigurations -- Bandit/Ruff/Semgrep/ZAP findings when their optional external engines are available -- Dangerous Supabase/Firebase usage patterns -- AWS CloudFormation template misconfigurations (public S3 ACLs, world-open - security groups, `*:*` IAM policies, public/unencrypted databases, secret - parameter defaults) -- API routes missing authentication -- Public Firebase rules (`read/write: true`) -- Dangerous CORS settings (`origin: "*"`) -- Missing Stripe webhook signature verification -- Unprotected admin routes -- Risky file upload handlers - -The scanner loads built-in Python rules and supported `pattern-regex` entries -from `scanner/rules/*.yml`. Semgrep-style structural `pattern:` entries remain -documented rule fixtures until the lightweight engine grows structural matching. - -Deploy-blocking counts focus on app code. Findings in docs, tests, examples, -and scanner fixtures stay visible but do not fail the deploy gate by default. - -#### Tune the gate with `.appguardrail.json` (optional) - -Commit a `.appguardrail.json` at the repo root to configure the deploy gate for -the whole team — no CLI flags needed: +# Add Trivy when it is installed and you want dependency/IaC coverage. +appguardrail scan --trivy . -```json -{ - "fail_on": "HIGH", - "exclude_rules": ["some-noisy-rule-id"] -} +# Add structural context when CodeGraph is installed. +appguardrail scan --codegraph . ``` -- `fail_on` — minimum severity that fails the gate (`CRITICAL`, `HIGH`, - `WARNING`, or `INFO`). Default gate blocks `CRITICAL` and `HIGH`. -- `exclude_rules` — rule ids to drop from the gate (findings still show, but - don't fail the build). An invalid config fails the scan loudly rather than - silently passing. +Supported external scanners are optional extensions. AppGuardrail's Python package currently declares no required runtime dependencies; external tools keep their own installation, execution, and license boundaries. -### Auto-fix safe issues +For an authorized running application, OWASP ZAP baseline can be invoked explicitly. Do not point active testing at a system you are not authorized to assess. ```bash -# Preview safe, deterministic fixes (dry-run diff) -appguardrail fix . - -# Apply them -appguardrail fix --apply . +appguardrail scan --zap-baseline https://your-authorized-test-host.example . ``` -`appguardrail fix` applies only **purely additive, semantics-preserving** -fixes — it will not silently rewrite behavior-changing code. The first -transform adds `rel="noopener noreferrer"` to external `target="_blank"` links -(reverse-tabnabbing). Behavior-changing fixes (moving a secret to an env var, -flipping TLS verification) stay as reviewable prompts — see -`appguardrail report fix-pack`. This closes the scan → fix → verify loop safely. +### Fix safely -### Run the control-plane API (scan history) +Preview deterministic fixes before changing source: ```bash -# Provision an org + API key file (defaults to cp.db.api-key) -appguardrail serve --db cp.db --create-org "Acme" --api-key-file acme.api-key - -# Run the API (bootstraps a default org + key on an empty DB) -appguardrail serve --db cp.db --port 8788 +appguardrail fix . ``` -`appguardrail serve` turns AppGuardrail from a one-shot CLI into a persistent, -multi-tenant surface: CI pushes each scan and the org queries its history. -New bootstrap keys are written to a local key file instead of console logs. +Apply only the supported safe transforms: ```bash -# From CI, after `appguardrail scan --findings-json findings.json .` -curl -X POST http://localhost:8788/api/v1/scans \ - -H "Authorization: Bearer $APPGUARDRAIL_API_KEY" \ - -H "Content-Type: application/json" \ - -d @findings.json # or {"repo":"...","commit":"...","findings":[...]} - -curl http://localhost:8788/api/v1/scans -H "Authorization: Bearer $APPGUARDRAIL_API_KEY" +appguardrail fix --apply . ``` -Push scans from CI with `appguardrail scan --push http://your-control-plane .` -(key from `APPGUARDRAIL_API_KEY`). The control plane computes **drift** — the -number of deploy-blocking findings newly introduced since the repo's previous -scan. Open the **org console** at `http://localhost:8788/` — a single static page that -connects with your API key and shows scan history, the deploy-blocking trend, -and per-scan detail. - -Issue role-scoped API keys with `POST /api/v1/keys` (owner only): `viewer` -(read), `member` (ingest scans), or `owner` (full). The bootstrap key is an -owner. - -Set a drift-alert webhook (`POST /api/v1/webhook` with `{"url":"…"}`) and the -control plane notifies it whenever a scan introduces new deploy-blocking -findings. If the URL is a Slack Incoming Webhook (`hooks.slack.com`), the alert -is automatically formatted as a Slack Block Kit message — a header with the new -blocker count plus the org, repo, scan id, and the top offending rule ids and -files — so Slack renders a readable card. Any other URL receives the generic -JSON payload unchanged. +AppGuardrail does not silently apply behavior-changing remediation. Changes that affect authentication, authorization, TLS, credentials, data access, or other security semantics stay reviewable and require explicit verification. -Endpoints: `POST /api/v1/scans`, `GET /api/v1/scans`, `GET /api/v1/scans/{id}`, -`POST /api/v1/webhook`, `GET /api/v1/health`. Tenant-isolated by API key. Stdlib + SQLite (swap for a -managed database behind the same functions at scale). +### Review and report -### Generate a CycloneDX SBOM +Generate a security-review prompt: ```bash -# Inventory dependencies as a CycloneDX 1.5 SBOM -appguardrail sbom . --out sbom.json +appguardrail review --stack nextjs --db supabase --payments stripe ``` -Parses `package-lock.json`/`package.json`, `pnpm-lock.yaml`, `yarn.lock`, -`requirements.txt`, and `poetry.lock` into a CycloneDX software bill of -materials — the component inventory buyers and auditors expect for -supply-chain diligence. Versions are resolved from the lockfile when present, -otherwise taken from the manifest (recorded per component). No third-party -dependency. - -### Generate reports from findings +Turn normalized findings into a bounded report: ```bash -appguardrail report buyer-diligence \ - --findings reports/findings.json \ - --out reports/buyer-diligence.md \ - --app-name "Demo SaaS" \ - --repository "ContextualWisdomLab/demo" - appguardrail report founder-friendly \ --findings reports/findings.json \ - --out reports/founder-security-review.md \ + --out reports/security-review.md \ --app-name "Demo SaaS" - -appguardrail report agency \ - --findings reports/findings.json \ - --out reports/agency-security-review.md \ - --app-name "Demo SaaS" \ - --client-name "Demo Client" \ - --reviewer "Demo Agency" - -appguardrail report fix-pack \ - --findings reports/findings.json \ - --out reports/fix-pack.md \ - --based-on "pre-launch-review-001" ``` -`appguardrail scan --findings-json` writes the normalized findings envelope that -the report command accepts. You can also pass a raw JSON array of findings or -any object with a `findings` array. Report types are: - -- `buyer-diligence`: buyer-readable launch posture and evidence checklist. -- `founder-friendly`: plain-language summary for non-security founders. -- `agency`: client-ready technical review and retest notes. -- `fix-pack`: AI-ready remediation prompts and verification steps. +Additional report profiles include `buyer-diligence`, `agency`, and `fix-pack`. Reports are designed to omit raw secrets while retaining actionable finding, remediation, and verification evidence. -Reports omit raw secrets and expand normalized metadata into launch posture, -finding summaries, remediation, and verification checklists. +## Continuous security -### View findings in a dashboard +Install the repository monitoring workflow: ```bash -# Generate findings, then open the local dashboard in your browser -appguardrail scan --findings-json reports/findings.json . -appguardrail dashboard +appguardrail monitor ``` -`appguardrail dashboard` serves a self-contained web dashboard that renders the -`appguardrail.findings.v1` file produced by `scan --findings-json`. It shows -severity counts, the deploy-blocking gate, findings by category, and a per-finding -detail view with the AppGuardrail Fix Format (Problem / Fix Prompt / Verification). +For local commit-time checks: ```bash -appguardrail dashboard --findings reports/findings.json # custom findings path -appguardrail dashboard --port 8899 # custom port -appguardrail dashboard --no-open # don't launch a browser +appguardrail hook ``` -No build step or dependencies — the dashboard is a single static page shipped -with the package (`scanner/dashboard/index.html`), so it also works from a -`pip install`. You can open it manually and drag a `findings.json` onto it. - -### Generate an organization buyer evidence bundle +When CodeGraph is available: ```bash -appguardrail org-bundle +appguardrail hook --codegraph ``` -This writes `appguardrail-buyer-evidence/` with: +The monitor and hook paths keep security review close to the change that introduced it instead of treating security as a one-time release exercise. -- `org-readiness.md`: buyer-readable organization readiness narrative. -- `buyer-evidence.json`: machine-readable KPI payload. -- `manifest.json`: source, timestamp, warning, repository, PR, and action bucket metadata. -- `README.md`: how to use the generated evidence packet. +## Findings dashboard -Use `--owner`, `--bundle-dir`, `--repos-json`, or `--prs-json` only when you -need a non-default organization, custom artifact path, or offline snapshot. - -### Install continuous monitoring +Create normalized findings and open the bundled dashboard: ```bash -appguardrail monitor +appguardrail scan --findings-json reports/findings.json . +appguardrail dashboard ``` -This installs `.github/workflows/appguardrail-monitor.yml`, which runs -`appguardrail scan .` on pull requests, pushes to common default branches, and -manual workflow dispatches. - -### Install the pre-commit hook - -```bash -appguardrail hook - -# Recommended when CodeGraph is available -appguardrail hook --codegraph -``` +The dashboard shows severity, deploy-blocking state, categories, and per-finding remediation/verification detail. It is shipped as a self-contained static page with the package. -The CodeGraph mode initializes or syncs the local structural index before each -scan. This gives human reviewers and AI review agents better call-graph context -for authorization, webhook, secret-handling, and other security-sensitive flows. -The repository Security Process workflow also runs AppGuardrail with CodeGraph -enabled, so pull requests get the same structural security context in CI. +## Control-plane mode -### Generate a security review prompt +Teams that need scan history can run the built-in control-plane surface: ```bash -appguardrail review --stack nextjs --db supabase --payments stripe +appguardrail serve --db cp.db --create-org "Demo Organization" --api-key-file demo.api-key +appguardrail serve --db cp.db --port 8788 ``` -Outputs a prompt you can paste directly into Claude Code or Cursor. - ---- - -## Repository Structure - -``` -appguardrail/ -├── README.md -├── rules/ # Security rules for AI coding tools -│ ├── cursor/ -│ ├── claude-code/ -│ ├── windsurf/ -│ └── lovable/ -├── checklists/ # Stack-specific security checklists -│ ├── auth.md -│ ├── authorization.md -│ ├── supabase.md -│ ├── firebase.md -│ ├── stripe.md -│ ├── file-upload.md -│ ├── api-security.md -│ ├── secrets.md -│ └── deployment.md -├── prompts/ # AI fix and review prompts -│ ├── secure-code-review.md -│ ├── fix-authz-bugs.md -│ ├── supabase-rls-review.md -│ ├── stripe-webhook-review.md -│ └── admin-route-review.md -├── scanner/ # Lightweight static analysis engine -│ ├── rules/ -│ │ ├── secrets.yml -│ │ ├── authz.yml -│ │ ├── supabase.yml -│ │ ├── firebase.yml -│ │ ├── nextjs.yml -│ │ └── stripe.yml -│ └── cli/ -│ └── appguardrail.py -├── reports/ # Report templates -│ └── templates/ -│ ├── founder-friendly-report.md -│ ├── agency-report.md -│ └── fix-pack.md -├── examples/ # Sample vulnerable and fixed apps -│ ├── vulnerable-vibe-app/ -│ └── fixed-vibe-app/ -└── docs/ # Methodology and responsible testing - ├── methodology.md - ├── scope-and-authorization.md - └── responsible-testing.md -``` +This mode provides tenant-scoped scan ingestion/history and bounded API-key roles. Newly generated bootstrap keys are written to a local key file instead of being printed to console output. Deployment identity, network exposure, database durability, backup/recovery, and secret management remain operator responsibilities; the local SQLite path is not itself a production-readiness claim. ---- +See the canonical architecture, security, and operability documents for the authority boundary before exposing this surface outside a controlled environment. -## The AppGuardrail Fix Format +## Supply-chain evidence -AppGuardrail doesn't hand you a traditional security report. Every finding comes with: +Generate a CycloneDX SBOM from supported project manifests and lockfiles: +```bash +appguardrail sbom . --out sbom.json ``` -Problem: - User A can access User B's project data by supplying B's project_id. -Risk: - Customer data may be exposed across users. +The resulting inventory is evidence about the scanned project. It does not relicense third-party components or by itself establish vulnerability-free, compliant, or production-ready status. -Fix Prompt: - "Update all project API routes to verify that the authenticated user's id - matches project.owner_id before returning data. Return 403 when ownership - does not match. Add tests for cross-user access." +## Security model -Verification: - Request User B's project_id using User A's token → expect HTTP 403. -``` +AppGuardrail follows a fail-closed bias for security-sensitive boundaries and keeps prevention, detection, and remediation authority distinct. ---- +- Findings are evidence to review; they are not proof that an application is secure. +- Optional external engines extend coverage but do not silently become required runtime dependencies. +- Deploy gates focus on application code by default while retaining non-blocking evidence from docs, tests, examples, and scanner fixtures. +- Invalid `.appguardrail.json` policy fails loudly rather than silently relaxing the gate. +- Active testing must stay within explicit authorization and scope. +- Security-sensitive fixes remain reviewable when a deterministic semantics-preserving transform is not possible. -## Why AppGuardrail is Different from Traditional SAST +For reporting vulnerabilities in AppGuardrail itself, follow [SECURITY.md](SECURITY.md). -Traditional scanners target classic vulnerabilities (SQLi, XSS). AI-coded apps fail differently: +## Configuration -| AI-coding failure mode | Example | -|---|---| -| Missing ownership check | Any user can read any record | -| Public storage bucket | Files accessible without auth | -| Exposed service role key | Full DB access from the browser | -| Supabase/Firebase rule mistake | RLS disabled or `allow read: if true` | -| Insecure webhook | No Stripe signature verification | -| AI-generated temporary code | `// TODO: add auth later` left in production | +A repository can commit `.appguardrail.json` to define the team-wide deploy threshold and bounded rule exclusions: ---- +```json +{ + "fail_on": "HIGH", + "exclude_rules": ["reviewed-rule-id"] +} +``` -## Services (Paid) +`fail_on` accepts `CRITICAL`, `HIGH`, `WARNING`, or `INFO`. Exclusions remove a rule from the deploy gate while leaving its findings visible for review. -| Product | Description | -|---|---| -| **AppGuardrail Snapshot** | One-time security assessment of your current app | -| **AppGuardrail Review** | Code, config, and authorization structure review | -| **AppGuardrail Red Team Lite** | Defensive penetration test based on real user scenarios | -| **AppGuardrail Fix Pack** | Patches and prompts to fix discovered issues | -| **AppGuardrail Retainer** | Monthly security review of every change | -| **AppGuardrail Monitor** | Continuous automated monitoring on commits and pull requests | +## Architecture and documentation ---- +AppGuardrail keeps detailed implementation, detector, evidence, and operating contracts outside the landing page so the README stays usable for builders and evaluators. -## Contributing +- [Documentation map](DOCUMENTATION.md) +- [Product requirements](docs/PRD.md) +- [Technical requirements](docs/TRD.md) +- [Architecture](ARCHITECTURE.md) +- [Architecture decisions](docs/adr/README.md) +- [Threat model](docs/THREAT_MODEL.md) +- [Test strategy](docs/TEST_STRATEGY.md) +- [Operability](docs/OPERABILITY.md) +- [Traceability](docs/TRACEABILITY.md) +- [Responsible testing](docs/responsible-testing.md) +- [Release automation](docs/release-automation.md) +- [Public documentation landing](docs/index.md) -This project is open-source and welcomes contributions of: -- New security rules for AI coding tools -- Stack-specific checklists -- Fix prompts for common vulnerability patterns -- Scanner detection rules +Package metadata currently classifies AppGuardrail as **Alpha**. Release, deployment, certification, customer, and commercial-readiness claims require their own current evidence; source documentation and passing development checks do not create those claims by themselves. -Please read [docs/responsible-testing.md](docs/responsible-testing.md) before contributing scanner rules. +## Contributing ---- +Contributions that improve security rules, stack-specific checks, remediation guidance, scanner detection, tests, or documentation are welcome. Read [docs/responsible-testing.md](docs/responsible-testing.md) before adding security tests or detector fixtures, and keep examples free of live credentials or unauthorized target data. ## License -MIT — see [LICENSE](LICENSE) +AppGuardrail source is licensed under the [MIT License](LICENSE). Third-party tools, dependencies, services, rulesets, and referenced standards retain their own terms. diff --git a/docs/index.md b/docs/index.md new file mode 100644 index 00000000..a9b7f63f --- /dev/null +++ b/docs/index.md @@ -0,0 +1,44 @@ +# AppGuardrail + +AppGuardrail is a security guardrail for AI-built applications. It helps teams catch common security problems during AI-assisted coding, deployment, operation, updates, and incident response instead of treating security as a one-time review. + +[Ask DeepWiki](https://deepwiki.com/ContextualWisdomLab/appguardrail) · [Repository](https://github.com/ContextualWisdomLab/appguardrail) · [Releases](https://github.com/ContextualWisdomLab/appguardrail/releases) + +## Start here + +```bash +python3 -m pip install appguardrail +appguardrail init +appguardrail scan . +``` + +The repository README contains the complete quick-start, supported tooling, optional scanners, reporting formats, and deployment-gate behavior. + +## Product surface + +AppGuardrail combines five complementary layers: + +- **Rules** for AI coding assistants and project guardrails. +- **Scan** for lightweight static checks, secrets, authentication gaps, configuration risks, and supported external scanners. +- **Review** for human-readable audit guidance and AI-assisted review prompts. +- **Monitor** for continuous GitHub Actions checks and normalized findings. +- **Fix** for remediation prompts, patch guidance, and re-verification. + +The CLI can emit normalized findings and SARIF for GitHub code scanning and other compatible consumers. Optional integrations extend coverage without changing AppGuardrail's core role as a developer-facing security control layer. + +## Documentation + +- [README and quick start](https://github.com/ContextualWisdomLab/appguardrail#quick-start) +- [Release automation](release-automation.md) +- [Security policy](https://github.com/ContextualWisdomLab/appguardrail/blob/develop/SECURITY.md) +- [Contributing](https://github.com/ContextualWisdomLab/appguardrail#contributing) + +Product plans, threat-model material, detector doctoring, operational guidance, and evidence stay versioned with the source so security claims can be reviewed alongside implementation changes. + +## Scope boundary + +AppGuardrail is not a substitute for authorization, threat modeling, dependency hygiene, runtime observability, penetration testing, or incident response. It provides repeatable guardrails and evidence that help teams find and remediate security risks earlier and more consistently. + +## Releases + +Published releases are the versioned delivery record. See the repository's [Releases](https://github.com/ContextualWisdomLab/appguardrail/releases) page for current release artifacts and notes.