outfence 0.1.0a2__tar.gz

outfence-0.1.0a2/CHANGELOG.md

@@ -0,0 +1,52 @@
+# Changelog
+
+## Unreleased
+
+## 0.1.0a2 - second alpha, first PyPI release
+
+- Publish releases to PyPI from GitHub Actions with Trusted Publishing, so no API token is stored. The release workflow runs the tests, requires the tag to match the package version, and smoke-tests the wheel.
+- Use absolute links and images in the README, so the PyPI project page renders it.
+- Show a real terminal recording of `outfence demo` in the README. It is an animated SVG made by `scripts/terminal_svg.py`, which uses the standard library only and replaces local paths before rendering.
+- Add an interactive terminal look, using the standard library only.
+  - The brand banner opens each run, and decisions print as they happen.
+  - The styled report ends with the goose pose for the outcome.
+  - `outfence` with no arguments shows a menu.
+  - Plain output for pipes, files and CI is unchanged. `NO_COLOR`, `OUTFENCE_COLOR`, `OUTFENCE_THEME` and `OUTFENCE_GOOSE` control the styling.
+- Add a model tap for local OpenAI-compatible servers (`run --model-upstream`) and destination provenance.
+  - Each proxy decision records which source first named the host: the user, the system prompt, a tool definition, a tool result, or only the model.
+  - Each decision also records the inferred tool call and, when the offered tools changed, a trigger candidate.
+  - A new optional `allow_from` policy key permits hosts named by trusted sources. Model output never authorizes a destination.
+  - The tap fails closed on unreadable answers and keeps no prompt or answer text.
+- Add a minimal stdio MCP fetch server and an MCP agent-loop example, with deterministic tests and a provenance walkthrough.
+
+- Replace generated HTML with terminal reports showing decisions, counts, coverage, and separate workload outcomes. Keep JSON evidence and existing exit codes.
+- Move planning drafts and obsolete schema examples into ignored local notes; retain practical user documentation.
+
+- Add a live Ollama/Qwen repository-research agent, with explicit proxied HTTPS tools, blocked/allowed policies, deterministic tests, and a reproducible walkthrough.
+
+- Replace the arrow-based identity with a minimal, monochrome split-ring symbol.
+- Skip reverse DNS during loopback server startup, preventing cold-process demo timeouts on macOS CI.
+- Add a regression check for DNS-free server startup and actionable smoke-test timeout output.
+
+## 0.1.0a1 - first alpha candidate
+
+### Added
+
+- Installable Python package with the `outfence` console command and no runtime dependencies.
+- `init`, `check`, `demo`, and `run` commands; JSON policy with exact host/port matching.
+- Local synthetic demo, enforce/observe modes, HTTP GET forwarding and CONNECT tunnels.
+- Offline HTML/JSON reports with policy snapshots, coverage limits, and workload outcomes.
+- Apache-2.0 license, contributor guidance, security scope, CI and package smoke checks.
+
+### Corrected from the initial prototype
+
+- Demo policy no longer depends on a source-checkout file after installation.
+- Invalid and unsupported requests are represented in evidence.
+- Upstream failures return an HTTP error and cannot produce a clean CLI outcome.
+- Output directories are reserved before workload launch; reports cannot be overwritten.
+- Active connections close at shutdown and incomplete evidence is disclosed.
+- Policies reject ambiguous values, duplicate rules and boolean versions/ports.
+
+### Limits
+
+Proxy-only coverage; no OS/container network isolation or tool attribution. macOS/Linux only. Initial source publication: github.com/gsaccardi/outfence. No package-registry release yet.

outfence-0.1.0a2/CONTRIBUTING.md

@@ -0,0 +1,40 @@
+# Contributing to Outfence
+
+Start with a small, reproducible problem. The current alpha is a proxy/report tool; container isolation is a separate investigation. Read the [README](README.md) and [security scope](SECURITY.md) before proposing stronger security claims.
+
+## Development
+
+Python 3.10+ on macOS/Linux:
+
+```sh
+python3 -m venv .venv
+source .venv/bin/activate
+python -m pip install -r requirements-dev.txt
+python -m pip install --no-build-isolation -e .
+ruff check outfence tests examples
+ruff format --check outfence tests examples
+python -m unittest discover -s tests -v
+python -m build --no-isolation
+```
+
+Use `ruff format outfence tests examples` to format changes. To check packaging, install the built wheel into a fresh virtual environment and run `scripts/smoke_install.py` with that environment's Python. It exercises the installed command from outside the checkout.
+
+Tests must not require paid APIs or external services. Use local fixtures, explicit synthetic endpoint mappings, and destination-side assertions. Do not expand the public policy schema to allow the internal fixture bypass.
+
+## Pull requests
+
+Explain the user-visible problem, the change, and how you verified it. Add regression coverage for behavior changes. Keep error and report strings free of request bodies, credentials, raw paths, and environment values. Update documentation when the supported behavior changes.
+
+Report normal bugs with the issue template. Follow [SECURITY.md](SECURITY.md) for sensitive findings. Treat contributors respectfully, focus criticism on the work, and do not post personal or confidential information.
+
+By submitting a contribution, you agree that it is provided under this repository's Apache-2.0 license. No additional CLA is required. Source files, tests, documentation, and generated artwork are included under that license; bundled third-party fonts are not distributed.
+
+The Ollama walkthrough has deterministic CI tests. Live model tests are manual and require an installed local model; do not add credentials, model downloads, or public API calls to CI.
+
+## Releasing
+
+Releases go to PyPI through Trusted Publishing: PyPI trusts the `Release` workflow's GitHub identity, so no API token exists anywhere.
+
+1. One-time setup: on PyPI, under Publishing, add a publisher for project `outfence` with owner `gsaccardi`, repository `outfence`, workflow `release.yml` and environment `pypi`. Before the first release this is a pending publisher.
+2. Bump `__version__` in `outfence/__init__.py`, move the `Unreleased` changelog entries under the new version, and merge.
+3. Publish a GitHub release whose tag is `v` plus the version, for example `v0.1.0a2`. The workflow runs the tests, refuses a tag that does not match the version, builds, smoke-tests the installed wheel and publishes.

outfence-0.1.0a2/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.

outfence-0.1.0a2/MANIFEST.in

@@ -0,0 +1,5 @@
+include LICENSE README.md CONTRIBUTING.md SECURITY.md CHANGELOG.md requirements-dev.txt
+recursive-include examples *.json *.py
+recursive-include docs *.md
+recursive-include brand *.md *.json *.svg *.png
+include scripts/smoke_install.py scripts/build_brand.py scripts/terminal_svg.py

outfence-0.1.0a2/PKG-INFO

@@ -0,0 +1,190 @@
+Metadata-Version: 2.4
+Name: outfence
+Version: 0.1.0a2
+Summary: Inspect proxy-routed agent connections with local policies and offline reports
+Author: Outfence contributors
+License-Expression: Apache-2.0
+Project-URL: Repository, https://github.com/gsaccardi/outfence
+Project-URL: Issues, https://github.com/gsaccardi/outfence/issues
+Project-URL: Changelog, https://github.com/gsaccardi/outfence/blob/main/CHANGELOG.md
+Project-URL: Homepage, https://gsaccardi.github.io/outfence/
+Keywords: ai-agents,proxy,network-policy,developer-tools
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Operating System :: POSIX
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Testing
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+<p align="center"><img src="https://raw.githubusercontent.com/gsaccardi/outfence/main/brand/assets/banner.png" alt="Outfence - Know where your agents connect." width="100%"></p>
+
+# Outfence
+
+**Know where your agents connect.**
+
+Outfence is a small, open source CLI that checks **proxy-routed outbound connections** against an allowlist and writes a terminal report and local JSON evidence. Use it to explore an agent's network dependencies and compare observation with blocking.
+
+We're exploring how teams can **test AI agents against their deployment policies**, starting with outbound network dependencies. The question: before deploying or updating an agent, which external services does it need, and what happens when access is denied?
+
+**Alpha 0.1.0a2, Apache-2.0, Python 3.10+, macOS/Linux, zero runtime dependencies**
+
+> This is a local development proxy, **not a network sandbox**. Programs can ignore proxy settings and connect directly. Outfence does not prevent all data leaks, inspect encrypted content, or certify data residency. See [security and coverage](https://github.com/gsaccardi/outfence/blob/main/SECURITY.md).
+
+## Try it in one minute
+
+Clone the repository and enter it:
+
+```sh
+git clone https://github.com/gsaccardi/outfence.git
+cd outfence
+```
+
+Then run:
+
+```sh
+python3 -m outfence demo
+```
+
+No installation, Docker, API key, model, or internet connection is needed for this demo. It starts temporary localhost services and makes real HTTP requests through the proxy:
+
+<p align="center"><img src="https://raw.githubusercontent.com/gsaccardi/outfence/main/docs/assets/terminal-demo.svg" alt="outfence demo in a terminal: model.example and retrieval.example are allowed, telemetry.example:80 is blocked, and the report ends with the goose blocking it" width="100%"></p>
+
+The CLI prints connection decisions, counts, exit status, and coverage limits directly in your terminal. In an interactive terminal it prints each decision as it happens, and the report ends with the Capitoline goose in the pose that matches the outcome. Pipes, files and CI get the plain text report. The recording above is real `outfence demo` output, rendered with `scripts/terminal_svg.py`. It also saves `report.json` under `runs/`; no HTML is generated. **Exit 2 is expected:** the example deliberately attempts a blocked destination. Each invocation creates a new report directory and shuts down its local servers.
+
+Compare observation mode:
+
+```sh
+python3 -m outfence demo --mode observe
+```
+
+All three fixture requests succeed; the last is recorded as `would_block`. Observation still exits 2 for a policy violation.
+
+## Install the command
+
+From [PyPI](https://pypi.org/project/outfence/), with [pipx](https://pipx.pypa.io/):
+
+```sh
+pipx install outfence
+outfence --version
+outfence demo
+```
+
+`python3 -m pip install outfence` inside a virtual environment works too. The application has no third-party runtime dependencies, and the installed command works anywhere. To install from a checkout instead, run `python -m pip install .` from the repository root in a virtual environment.
+
+## Change a rule
+
+```sh
+outfence init demo-policy.json --demo
+outfence check demo-policy.json
+outfence demo --policy demo-policy.json
+```
+
+Add `{"host": "telemetry.example", "port": 80}` to the policy's `allow` array and rerun. All three demo requests should now succeed, with exit 0. Remove it to restore the blocked case.
+
+A policy has an implicit default deny and exact hostname/port rules:
+
+```json
+{
+  "version": 1,
+  "allow": [
+    {"host": "api.example.com", "port": 443}
+  ]
+}
+```
+
+`outfence init outfence.json` creates a **deny-all** policy. Hosts must be lowercase ASCII names (punycode for international names) or canonical IP addresses. Wildcards, trailing dots, duplicate rules, unknown fields, and invalid ports are rejected. Non-public upstream addresses remain blocked even if listed. Only the internal demo/test fixtures map synthetic names to localhost.
+
+## Run a proxy-aware program
+
+```sh
+outfence run --policy outfence.json --timeout 60 -- python3 my_agent.py
+```
+
+The runner sets `HTTP_PROXY`, `HTTPS_PROXY`, and lowercase equivalents, and clears `NO_PROXY`. The program must honor them. Your command runs with your normal permissions, credentials, and API costs; Outfence is not an execution sandbox.
+
+| Supported in this alpha | Outside coverage |
+|---|---|
+| HTTP GET forwarding | HTTP POST/PUT/etc. forwarding, custom HTTP headers and authentication |
+| CONNECT tunnels used by HTTPS clients | TLS/content inspection, confirmation that tunnel bytes are actually TLS |
+| Exact destination rules and public-address checks | Direct sockets, clients that ignore proxy settings, remote service downstream connections |
+| Local JSON policy snapshot and terminal decisions | Authenticated tool/process attribution and complete traffic inventory |
+| Destination provenance from non-streaming chat completions to a local model server (`--model-upstream`) | Streaming responses, hosted model APIs, harnesses that mislabel message roles |
+| Workload timeout and ordinary child process cleanup | Host isolation, detached-process containment, Windows support |
+
+HTTPS uses the client's normal end-to-end TLS connection. Plain HTTP forwarding intentionally preserves only Host and Connection request headers and Content-Type/Location response headers; it is intended for simple diagnostics. CONNECT idle timeout is 15 seconds; socket operations time out after 10 seconds. See [CLI reference](https://github.com/gsaccardi/outfence/blob/main/docs/CLI.md) for resource limits and outcomes.
+
+## Run a real agent
+
+Try the [local Ollama + GitHub walkthrough](https://github.com/gsaccardi/outfence/blob/main/docs/OLLAMA-WALKTHROUGH.md). A real Qwen model chooses two repository tools: Outfence permits metadata access and blocks the README until you change the policy. No API key is needed; an installed local model and internet access for the public tools are required. Model inference is deliberately outside proxy coverage.
+
+```sh
+python3 -m outfence run --policy examples/ollama-policy.json --timeout 300 -- python3 examples/ollama_agent.py
+```
+
+## See where a destination came from (preview)
+
+An agent reaches the network through tools that the model chooses to call. With `--model-upstream`, Outfence also sits between the agent and a **local** OpenAI-compatible model server (Ollama, mlx-lm, llama.cpp, vLLM). For every destination it records which source first named the host: the user, the system prompt, a tool definition, a tool result, or **only the model**. A policy can then allow hosts the user asked for. The model's own output never authorizes a destination.
+
+```sh
+python3 -m outfence run --policy examples/provenance-policy.json \
+  --model-upstream http://127.0.0.1:11434 --timeout 300 \
+  -- python3 examples/mcp_agent.py --model qwen2.5:7b --server fetch-mcp \
+     --question "Open the official Python documentation website and tell me its title."
+```
+
+```text
+BLOCKED      docs.python.org:443
+  model_originated | not_attempted
+  origin: named only by the model; the user, system prompt, tools and tool results never did
+  tool call: mcp__fetch-mcp__request_url
+```
+
+Ask the agent to fetch `https://example.com/` instead, and the same policy allows it as `allow_from_user`. A model backdoored to call home when a particular MCP server appears produces exactly this signature: a destination nobody named, right after the tool environment changed. CERT-AgID described such a backdoor in November 2026, and in that case the report adds `trigger?: MCP server … appeared N s before this request`. Matching is textual, and the harness's message roles are trusted. See the [provenance walkthrough](https://github.com/gsaccardi/outfence/blob/main/docs/PROVENANCE-WALKTHROUGH.md) and the [security notes](https://github.com/gsaccardi/outfence/blob/main/SECURITY.md).
+
+## Read the result
+
+Reports contain destination host/port, decision, reason, connection status, timestamps, policy snapshot, and coverage limits. With the model tap, they also contain each destination's origin, tool names, and tool-environment changes. They contain no stored request paths, bodies, headers, prompts, answers, environment values, or command output. Workload stdout/stderr remains visible in your terminal. Hostnames can still be sensitive; review reports before sharing.
+
+| Exit | Meaning |
+|---|---|
+| 0 | Workload completed; no proxy violations or recorded proxy failures. Coverage is still proxy-only. |
+| 2 | At least one blocked or would-block request |
+| 3 | Setup/transport error, interruption, event loss, or unfinished request at shutdown |
+| 4 | Workload failed without a higher-priority outcome |
+
+Exit precedence: **3 → 2 → 4 → 0**. The workload's original exit code is recorded separately. An empty report means no proxy requests were observed; it does not prove there was no network activity.
+
+Reports stay on your machine with owner-only file permissions. Use `--output NEW_DIRECTORY` to choose a location. Existing directories are refused before launching your command. See the [report format](https://github.com/gsaccardi/outfence/blob/main/docs/REPORT.md).
+
+## Contribute
+
+```sh
+python -m pip install -r requirements-dev.txt
+ruff check outfence tests examples
+ruff format --check outfence tests examples
+python -m unittest discover -s tests -v
+python -m build --no-isolation
+```
+
+Tests use local fixtures and verify destination-side receipt. CI is configured for Python 3.10/3.13 on Linux and macOS, including installing the built wheel and running it outside the checkout. See [CONTRIBUTING.md](https://github.com/gsaccardi/outfence/blob/main/CONTRIBUTING.md).
+
+Useful first contributions: sanitized agent-client compatibility cases, clearer report explanations, and feedback from people answering customer network-security questions.
+
+## Feedback and scope
+
+We're investigating deployment checks for agents that teams build or adopt, starting with network dependencies. The Ollama walkthrough is the current verified real-agent example. Codex, Claude Code, and Copilot compatibility has not been verified.
+
+What evidence would your team need before deploying an agent? [Open an issue](https://github.com/gsaccardi/outfence/issues) with a synthetic or sanitized workflow, the decision you need to make, and what your current tools cannot show.
+
+- [CLI reference](https://github.com/gsaccardi/outfence/blob/main/docs/CLI.md)
+- [JSON format](https://github.com/gsaccardi/outfence/blob/main/docs/REPORT.md)
+- [Security](https://github.com/gsaccardi/outfence/blob/main/SECURITY.md)
+- [Architecture](https://github.com/gsaccardi/outfence/blob/main/docs/ARCHITECTURE.md)
+- [Changelog](https://github.com/gsaccardi/outfence/blob/main/CHANGELOG.md)
+- [Brand kit](https://github.com/gsaccardi/outfence/blob/main/brand/README.md)
+
+Licensed under [Apache-2.0](https://github.com/gsaccardi/outfence/blob/main/LICENSE). GitHub: [gsaccardi/outfence](https://github.com/gsaccardi/outfence). PyPI: [outfence](https://pypi.org/project/outfence/). No domain name has been registered yet.