permitprobe 0.1.1__tar.gz

permitprobe-0.1.1/AGENTS.md

@@ -0,0 +1,15 @@
+# PermitProbe
+
+Independent security regression CLI. Python 3.11+, POSIX handoff reader.
+
+- Keep policy parsing strict and report exit codes 0/pass, 1/violation, 2/inconclusive.
+- Unknown outcomes and failed positive controls must never produce a clean run.
+- Reports contain labels and findings, not credentials, response bodies or scanned text.
+- The library reuses Overstep and Gitleaks; do not silently widen their execution scope.
+- All fixtures are synthetic. Tests use loopback; never point tests at production.
+- Run `python -m pytest -q` and `ruff check src tests scripts` for behavior changes.
+  Gitleaks 8.30.1 must be installed; missing-engine tests may not be silently skipped.
+- Keep explicit boundary checks and the checked-byte bundle guarantee covered by tests.
+- Keep examples, README and the generated policy schema synchronized.
+- Do not commit environments, generated reports, archives, private data or scanner binaries.
+- Keep optional future integrations clearly distinguished from implemented capabilities.

permitprobe-0.1.1/CONTRIBUTING.md

@@ -0,0 +1,47 @@
+# Contributing
+
+Start with the installation and test commands in README.md. Keep examples synthetic.
+Use an issue to describe a reproducible boundary failure, expected policy, and current
+coverage gap. Security-sensitive reports belong in the private reporting channel.
+
+A useful change includes a failing fixture, the smallest correction, and a passing
+regression. Keep API authorization, response schemas, and handoff checks independently
+usable. Document untested surfaces and errors explicitly; never trade them for a green exit.
+
+The public contract is the policy schema, CLI, report schema, exit-code semantics, and
+checked-bundle manifest. Change them deliberately and update examples and tests together.
+Public documentation is in English. Contributions are provided under Apache-2.0.
+
+## Publishing a verified GitHub release to PyPI
+
+The distribution, import package, and command are all named `permitprobe`. The former
+name `boundaryguard` is already used by an unrelated PyPI project. Keep historical
+GitHub tags and assets unchanged; the rename is released as v0.1.1.
+
+One-time account setup belongs to the maintainer: create a PyPI account, verify its
+email and configure two-factor authentication, then add a pending GitHub publisher at
+<https://pypi.org/manage/account/publishing/> using:
+
+| Field | Value |
+| --- | --- |
+| PyPI project name | `permitprobe` |
+| GitHub owner | `Chorolee` |
+| GitHub repository | `permitprobe` |
+| Workflow filename | `publish-pypi.yml` |
+| GitHub environment | `pypi` |
+
+No long-lived PyPI token is stored in this repository. See the official
+[pending publisher guide](https://docs.pypi.org/trusted-publishers/creating-a-project-through-oidc/).
+A pending publisher does not reserve a name or publish a package.
+
+Before publication, run **Publish verified release to PyPI** on `main` with the
+release tag and `publish=false`. This downloads the existing GitHub wheel and source
+distribution, verifies their GitHub SHA256 digests, checks package name/version,
+and runs strict metadata validation. It does not rebuild or upload the package.
+After account setup and a successful validation, run the same workflow with
+`publish=true`. Only the upload job receives the short-lived OIDC publishing permission.
+
+Confirm the public PyPI version and file hashes after upload before adding registry
+installation instructions to the README. Publication establishes availability;
+downloads or dependent projects must be reported from real, independently verifiable
+usage. Do not equate an automated installation with a distinct external user.

permitprobe-0.1.1/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

permitprobe-0.1.1/MANIFEST.in

@@ -0,0 +1,5 @@
+include AGENTS.md CONTRIBUTING.md SECURITY.md NOTICE LICENSE
+include requirements.lock permitprobe.schema.json
+recursive-include examples *.json *.txt
+recursive-include scripts *.py
+recursive-include tests *.py

permitprobe-0.1.1/NOTICE

@@ -0,0 +1,23 @@
+PermitProbe
+Copyright 2026 PermitProbe contributors
+
+PermitProbe is independently implemented and uses third-party software:
+
+- Overstep 1.5.0, https://github.com/kabiri-labs/overstep (Apache-2.0)
+  Copyright and notices remain with its authors. Installed as a dependency.
+- Gitleaks 8.30.1, https://github.com/gitleaks/gitleaks (MIT)
+  Invoked as a separately installed executable; not bundled in this repository.
+- jsonschema, https://github.com/python-jsonschema/jsonschema (MIT)
+  Installed as a dependency.
+
+Each dependency retains its own license and notices. The repository contains
+synthetic demonstrations, not production data, credentials, or private source.
+
+Related work considered for later adapters:
+Supabase Test Helpers (MIT) and rlsautotest (Apache-2.0).
+Neither is included in, or required by, the current implementation.
+
+Conceptual design reference:
+ARTEX, https://github.com/Autumn-27/ARTEX (reviewed source: AGPL-3.0).
+No ARTEX code, prompts, screenshots, or assets are included. See README.md for
+the reviewed revision and the proposed independently implemented adaptations.

permitprobe-0.1.1/PKG-INFO

@@ -0,0 +1,258 @@
+Metadata-Version: 2.4
+Name: permitprobe
+Version: 0.1.1
+Summary: Repeatable API, response-data, and AI handoff boundary checks
+Maintainer: Chorolee
+License-Expression: Apache-2.0
+Project-URL: Repository, https://github.com/Chorolee/permitprobe
+Project-URL: Issues, https://github.com/Chorolee/permitprobe/issues
+Project-URL: Releases, https://github.com/Chorolee/permitprobe/releases
+Project-URL: Security, https://github.com/Chorolee/permitprobe/security/policy
+Keywords: security,authorization,api-security,security-testing
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+License-File: NOTICE
+Requires-Dist: overstep==1.5.0
+Requires-Dist: jsonschema<5,>=4.23
+Provides-Extra: dev
+Requires-Dist: pytest<10,>=8; extra == "dev"
+Requires-Dist: ruff<1,>=0.12; extra == "dev"
+Requires-Dist: build<2,>=1.2; extra == "dev"
+Requires-Dist: twine<7,>=6; extra == "dev"
+Dynamic: license-file
+
+# PermitProbe
+
+[![CI](https://github.com/Chorolee/permitprobe/actions/workflows/ci.yml/badge.svg)](https://github.com/Chorolee/permitprobe/actions/workflows/ci.yml) [![License: Apache-2.0](https://img.shields.io/badge/License-Apache--2.0-blue.svg)](LICENSE) [![Release](https://img.shields.io/github/v/release/Chorolee/permitprobe)](https://github.com/Chorolee/permitprobe/releases)
+
+Open-source defensive security CLI for testing API authorization, response-data boundaries, and AI handoff exposure.
+
+Maintainer: @Chorolee<br>
+Security Maintainer: @Chorolee<br>
+Security maintenance: vulnerability triage, security releases, and coordinated disclosure.
+
+License: Apache-2.0 · Current release: [v0.1.1](https://github.com/Chorolee/permitprobe/releases/tag/v0.1.1)
+
+PermitProbe helps service operators validate:
+
+- cross-user authorization boundaries
+- unexpected API response fields
+- secrets included in AI handoff files
+
+It is designed exclusively for systems the operator owns or is authorized to test.
+
+PermitProbe was developed from recurring defensive security checks used while operating data-backed production services.
+
+PermitProbe is an early open-source CLI for small teams running data-backed services.
+It turns an explicit policy into repeatable checks and a local, machine-readable report.
+It reuses [Overstep](https://github.com/kabiri-labs/overstep) for authorization planning and
+classification, [JSON Schema](https://github.com/python-jsonschema/jsonschema) for response
+contracts, and [Gitleaks](https://github.com/gitleaks/gitleaks) for secret detection.
+
+Version **0.1.1** supports GET-only JSON REST APIs and explicit UTF-8 text-file handoffs on
+Linux/macOS. A passing result applies only to the declared cases and scanned bytes.
+
+## Try the working demo
+
+PyPI publication is being configured. Until an upload is verified, install from
+this repository or its GitHub Release files. Maintainers can follow the
+[Trusted Publishing setup](CONTRIBUTING.md#publishing-a-verified-github-release-to-pypi).
+
+The project was renamed from BoundaryGuard in v0.1.1 because the PyPI package
+`boundaryguard` belongs to an unrelated project. The historical v0.1.0 release
+remains unchanged.
+
+Python 3.11+ is required. From this repository:
+
+```sh
+python3 -m venv .venv
+. .venv/bin/activate
+python -m pip install -c requirements.lock -e '.[dev]'
+python scripts/install_gitleaks.py
+
+permitprobe demo --scenario safe --gitleaks .tools/gitleaks
+permitprobe demo --scenario leaky --gitleaks .tools/gitleaks
+permitprobe demo --scenario expired --gitleaks .tools/gitleaks
+```
+
+The demos start an ephemeral server on literal loopback and use synthetic credentials
+and documents. They do not contact an application or a database.
+
+| Scenario | Expected exit | What it demonstrates |
+| --- | --- | --- |
+| `safe` | `0` | Both users can read their own document; cross-owner reads are denied; fields and handoff match policy |
+| `leaky` | `1` | Cross-owner access, an extra private response field, and a synthetic token in a handoff are detected |
+| `schema-leak` | `1` | Authorization can be correct while the response exposes an extra field |
+| `expired` | `2` | One user's working credential cannot hide another user's failed positive control |
+| `server-error` | `2` | A server error on a negative test is not evidence that authorization worked |
+
+Exit `1` and `2` in the last examples are intentional. No response bodies, token values,
+file contents, or raw scanner diagnostics are included in PermitProbe reports.
+
+## Check your own staging API
+
+```sh
+permitprobe init my-security-checks
+```
+
+Edit `my-security-checks/permitprobe.json`:
+
+- Set the HTTPS origin of a target you operate. HTTP is accepted only for literal loopback.
+- Name one anonymous identity and at least two authenticated identities with distinct objects.
+- Point `token_env` at environment variables containing the corresponding bearer tokens.
+  PermitProbe does not read dotenv files, create users, or obtain credentials.
+- Declare each resource's allowed roles and `own`/`any` scope.
+- For object resources, name the URL parameter, identity attribute, and JSON pointer that
+  proves a successful response actually returned the intended object.
+- Set `response_schema` and `denial_schema` for successful and refused responses.
+  Close objects with `additionalProperties: false`, including nested objects, when all
+  undeclared fields must be forbidden. The starter also constrains denial error values.
+- Select only the text files intended for an AI handoff. Paths are relative to `handoff.root`,
+  itself relative to the policy file. They are never inferred from the whole repository.
+
+After supplying the token variables through your normal local credential mechanism:
+
+```sh
+permitprobe check my-security-checks/permitprobe.json \
+  --gitleaks .tools/gitleaks --report result.json
+```
+
+The starter origin is a non-working `example.invalid` placeholder. A missing token,
+unreachable target, unsupported response, failed control, or missing scanner exits `2`.
+Reports and exports are created exclusively; existing files are not overwritten.
+
+Use `permitprobe schema` to print the policy's JSON Schema. Unknown policy keys,
+duplicate JSON keys, reused object IDs, and reused token references are rejected.
+`examples/permitprobe.json` is a complete configuration with synthetic placeholders.
+
+## Check and package an AI handoff
+
+```sh
+permitprobe bundle my-security-checks/permitprobe.json \
+  --gitleaks .tools/gitleaks --output reviewed-handoff.zip
+```
+
+`bundle` checks the **handoff surface only** and makes no API requests. Its report states
+that API/data surfaces were not checked. It captures each named file, checks the captured
+bytes with Gitleaks, and only emits a ZIP when all handoff checks pass. The ZIP contains a
+SHA256 manifest and those exact bytes, even if source files change afterward. Nothing is
+uploaded or sent to an agent. Send the checked archive, not a re-read of the original tree.
+
+The built-in boundary refuses dotenv files, private-key files, credential directories,
+Git/private-memory directories, symlinks, hard links, non-regular files, binary content,
+path traversal, and configured size overruns. User deny patterns win over allow patterns;
+neither can override the built-in exclusions. Glob patterns match the whole POSIX path,
+and `*` can cross directory separators. Include specific files rather than a broad `*`.
+
+Scanner configuration and inline `gitleaks:allow` comments in a payload cannot suppress
+the scan. Gitleaks runs with a small explicit environment, without inherited credentials
+or configuration overrides. It receives neutral filenames and private temporary files.
+These controls are a preflight check, not a sandbox for a malicious scanner executable.
+
+## What is reused, and what PermitProbe adds
+
+| Component | Responsibility |
+| --- | --- |
+| Overstep **1.5.0** | Generate identity/resource cases and classify unexpected access, including cross-owner access |
+| JSON Schema / `jsonschema` | Validate nested JSON response contracts |
+| Gitleaks **8.30.1** | Detect known secret patterns in captured handoff text |
+| PermitProbe | Strict configuration, bounded GET transport, per-identity positive controls, object identity checks, success **and denial** response contracts, explicit file boundaries, checked-byte bundles, and one privacy-conscious report |
+
+The Gitleaks installer pins the release and archive hashes. `requirements.lock` records
+the tested Python dependency versions. Engine updates must pass the regression fixtures.
+No code from a source-available-only security product is embedded here.
+
+An auth-only matrix can be exported for direct use with Overstep:
+
+```sh
+permitprobe export-overstep my-security-checks/permitprobe.json --output matrix.json
+```
+
+The output is JSON, also valid YAML for Overstep, and retains `${TOKEN_ENV}` references.
+It does **not** include PermitProbe's JSON Schema checks, strict control rules, or
+handoff checks. Direct Overstep execution has its own behavior and scope.
+
+## Exit codes and evidence
+
+| Exit | Meaning |
+| --- | --- |
+| `0` | Every configured check completed and passed |
+| `1` | At least one policy violation; no incomplete checks |
+| `2` | Configuration error or incomplete evidence; failures may also be present |
+
+`--format json` prints the versioned report. `--report path.json` additionally creates
+a local report file. Unconfigured surfaces are named explicitly. An empty run cannot pass.
+Responses are consumed only in memory and capped in size/time. Proxy environment variables,
+redirects, automatic login, fixture mutations, and shared cross-identity cookie jars are not used.
+
+## Scope and limitations
+
+- Only declared GET cases are tested. This is not a full application security audit.
+- A forbidden `2xx` response is an access-policy violation; content markers can strengthen
+  evidence, but a status code alone does not prove a particular secret was disclosed.
+- The owner must supply the intended policy, real test identities, and existing test objects.
+  A wrong policy or overly permissive JSON Schema can produce misleading conclusions.
+- JSON Schemas are inline Draft 2020-12; reference resolution and format enforcement are
+  not supported. Denial responses must also be valid JSON matching their declared schema.
+- These are API observations, **not** a proof of database grants, RLS, storage, GraphQL,
+  caching, or write-path correctness. The tool never connects to a database in v0.1.
+- Handoff scanning covers selected UTF-8 text only. It is not complete PII classification,
+  archive scanning, prompt-injection prevention, continuous DLP, or runtime egress enforcement.
+- Policy files, schemas, the installed dependencies, and the chosen scanner executable are
+  trusted. Reports retain configured labels and filenames; do not put secrets in those names.
+- GET handlers must actually be safe to call. Choose a staging target with synthetic fixtures.
+
+## Development
+
+```sh
+python -m pytest -q
+ruff check src tests scripts
+python -m build
+```
+
+Tests use real loopback HTTP and the installed Gitleaks binary. Missing Gitleaks fails the
+suite rather than silently skipping secret-detection tests. Set `PERMITPROBE_GITLEAKS`
+to an absolute binary path when it is not at `.tools/gitleaks`.
+
+## What expanding verification means
+
+This means adding **security checks that users can apply to their services**, separately
+from adding unit tests for PermitProbe itself. The present regression suite tests the
+tool against synthetic safe, vulnerable, and inconclusive cases; it does not audit a
+deployed application automatically.
+
+| Planned capability | Concrete question it would test |
+| --- | --- |
+| Database adapter (Supabase/pgTAP) | Can one authenticated user directly read another user's private row, even if the HTTP API denies it? |
+| Linked API/storage cases | Does a document denied by its API remain readable through a direct object URL or another declared route? |
+| Write authorization cases | Can a user modify or delete another user's seeded test record? Run against disposable test data with explicit write-test scope. |
+| MCP adapter | Can an agent identity invoke a tool or name a resource outside its declared permissions? |
+| Finding history and retests | Is a previously reproduced defect still present after a change, with valid credentials and a working positive control? |
+
+These are **not implemented in v0.1**. Each addition needs a known-vulnerable fixture,
+a fixed counterpart, and an incomplete-evidence case that must not pass.
+
+## Design reference: ARTEX
+
+[ARTEX](https://github.com/Autumn-27/ARTEX) is an AI-driven penetration-testing system.
+Reference review: [revision b55ceb1](https://github.com/Autumn-27/ARTEX/tree/b55ceb1fdd84a813d77de09a06af83d323a81f85).
+Its documented asset/exploration graphs distinguish targets from investigation progress;
+its finding retests retain prior evidence and separate reproduced, fixed, and inconclusive
+outcomes. See its [architecture](https://github.com/Autumn-27/ARTEX/blob/b55ceb1fdd84a813d77de09a06af83d323a81f85/README.md),
+[retest model](https://github.com/Autumn-27/ARTEX/blob/b55ceb1fdd84a813d77de09a06af83d323a81f85/db/finding_retests.go),
+and [evidence store](https://github.com/Autumn-27/ARTEX/blob/b55ceb1fdd84a813d77de09a06af83d323a81f85/evidence/store.go).
+
+The proposed PermitProbe adaptation is a scoped workflow: inventory declared surfaces,
+identify a candidate, reproduce it with an executable check, retain safe evidence metadata,
+then rerun the same case after a fix. A future AI-assisted discovery layer would produce
+candidates; configured executable checks would decide the result. Any coverage view must
+keep untested surfaces visible. Response bodies and credentials would remain excluded from
+ordinary reports under this project's existing data-handling contract.
+
+ARTEX's reviewed source is [AGPL-3.0](https://github.com/Autumn-27/ARTEX/blob/b55ceb1fdd84a813d77de09a06af83d323a81f85/LICENSE).
+It is a **conceptual reference**, not an installed dependency or an imported implementation.
+No ARTEX code, prompts, screenshots, or other assets are copied into PermitProbe.
+This reference review does not claim to have run or audited ARTEX.
+
+Apache-2.0. See [NOTICE](NOTICE), [CONTRIBUTING.md](CONTRIBUTING.md), and [SECURITY.md](SECURITY.md).