engineering-argument-language 3.2.3__tar.gz → 3.2.4__tar.gz

{engineering_argument_language-3.2.3 → engineering_argument_language-3.2.4}/CONTRACT.md

@@ -1,6 +1,6 @@
 # EAL/3 integration contract
 
-EAL/3 is the supported source language. The Python distribution is `engineering-argument-language` version `3.2.3`, imported as `eal`, and its source notation uses newline-terminated fields and typed flows. The source language, persisted `EAL/observation-record/1`, typed `EAL/typed-input/1`, compact `EAL/assessment-packet/2` and registered `EAL/registered-assessment/1` results are separate contracts. See [language syntax](docs/language.md), [reasoning modes](docs/reasoning-modes.md) and the [argument service](docs/argument-service.md).
+EAL/3 is the supported source language. The Python distribution is `engineering-argument-language` version `3.2.4`, imported as `eal`, and its source notation uses newline-terminated fields and typed flows. The source language, persisted `EAL/observation-record/1`, typed `EAL/typed-input/1`, compact `EAL/assessment-packet/2` and registered `EAL/registered-assessment/1` results are separate contracts. See [language syntax](docs/language.md), [reasoning modes](docs/reasoning-modes.md) and the [argument service](docs/argument-service.md).
 
 Source fields use newlines, contexts resolve metadata defaults, and typed support flows lower to the existing argument model. Package, source notation and stored observation versions remain separate. Strictness, ranks and contraries retain their opt-in ASPIC+ compilation effects.
 
@@ -49,7 +49,7 @@ FastMCP `4.0.10` supplies stdio and Streamable HTTP transports through MCP Pytho
 
 The HTTP runner always enables strict Host/Origin protection before MCP handling. Accepted hosts include FastMCP's loopback defaults, the configured host, the actual bound address and `allowed_hosts` additions. Supplied origins must match the request's origin, qualify as loopback on a loopback request, or appear in `allowed_origins`. Untrusted Host and Origin headers receive HTTP 421 and 403 respectively. `[server.http].allowed_hosts` and `.allowed_origins` contain up to 128 unique literal entries each; repeated `--allowed-host` / `--allowed-origin` options and JSON-array `EAL_MCP_ALLOWED_HOSTS` / `EAL_MCP_ALLOWED_ORIGINS` variables follow normal precedence. Wildcards are rejected.
 
-Non-loopback HTTP binds and additional non-loopback trusted hosts/origins require `--token-env NAME` or `[server.http].token_env`, including public proxies forwarding to loopback. Startup reads the token from that environment variable; settings and source contain only its name. The bearer credential grants access to the endpoint's fixed operator workspace or registered-entry allowlist. The service implements one host trust domain per endpoint. HTTP clients use `eal-host --url URL [--token-env NAME]`; this connects to an already running service and treats the credential as an opaque bearer value. The host's default route launches a stdio subprocess, and its flat JSON `compile_aspic` operation uses the same checked contract as `eal_compile_aspic`. Credential sanitisation preserves JSON field names and public host metadata, while redacting application string values and diagnostics, including values in JSON-bearing content text. See [MCP and tools](docs/mcp-and-tools.md) for settings and examples.
+Non-loopback HTTP binds and additional non-loopback trusted hosts/origins require `--token-env NAME` or `[server.http].token_env`, including public proxies forwarding to loopback. Startup reads the token from that environment variable; settings and source contain only its name. The bearer credential grants access to the endpoint's fixed operator workspace or registered-entry allowlist. The service implements one host trust domain per endpoint. HTTP clients use `eal-host --url URL [--token-env NAME]`; this connects to an already running service and treats the credential as an opaque bearer value. The host's default route launches a stdio subprocess, and its flat JSON `compile_aspic` operation uses the same checked contract as `eal_compile_aspic`. Credential sanitisation preserves fixed host and MCP content-block fields and public metadata, while redacting application object keys, string values, extra wrapper fields and diagnostics, including escaped keys in JSON-bearing text. Unsafe JSON-looking text is replaced in full; collisions between sanitised object keys produce one error response with exit code 2. See [MCP and tools](docs/mcp-and-tools.md) for settings and examples.
 
 Collections bind exact source bytes and context. The evaluator reports `supported`, `contested`, `unsupported` or `out_of_scope` for claims; it also returns named argument, evidence, assumption, objection and reasoning results. Objections and support dependencies are solved under the finite authored argument model. An `unsupported` result does not assert the opposite claim. Typed propositions check formal correspondence and result predicates within the installed method's limits; human review remains responsible for whether an authored claim and its measurement answer the intended engineering question.
 

{engineering_argument_language-3.2.3 → engineering_argument_language-3.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: engineering-argument-language
-Version: 3.2.3
+Version: 3.2.4
 Summary: An ANTLR4 language and MCP interpreter for engineering reasoning and argumentation
 Author: Emmett Miller
 Maintainer: Emmett Miller
@@ -41,7 +41,7 @@ Dynamic: license-file
 
 EAL/3 records engineering claims, their evidence requirements, reasoning methods, assumptions and objections in reusable source files. A Python host binds declared tools to a separate TOML configuration, collects observations, assesses claims and stores the result. Later sessions and different models can find the same source and reuse compatible observations until they expire.
 
-The Python distribution is **`engineering-argument-language` 3.2.3** and requires Python **3.11 or later**; application code imports `eal`. The supported source language is `EAL/3`, with newline-terminated fields and typed flows. Stored tool results use `EAL/observation-record/1`; model-facing summaries use `EAL/assessment-packet/2`.
+The Python distribution is **`engineering-argument-language` 3.2.4** and requires Python **3.11 or later**; application code imports `eal`. The supported source language is `EAL/3`, with newline-terminated fields and typed flows. Stored tool results use `EAL/observation-record/1`; model-facing summaries use `EAL/assessment-packet/2`.
 
 ## Author a bounded argument
 
@@ -82,18 +82,18 @@ Create a virtual environment, then install a built or downloaded wheel:
 ```bash
 python3 -m venv .venv
 . .venv/bin/activate
-python -m pip install ./engineering_argument_language-3.2.3-py3-none-any.whl
+python -m pip install ./engineering_argument_language-3.2.4-py3-none-any.whl
 eal --help
 ```
 
-After the maintainer creates the `v3.2.3` release tag, a pinned source installation is also available:
+After the maintainer creates the `v3.2.4` release tag, a pinned source installation is also available:
 
 ```bash
 python -m pip install \
-  'engineering-argument-language @ git+https://github.com/emmett08/earl.git@v3.2.3'
+  'engineering-argument-language @ git+https://github.com/emmett08/earl.git@v3.2.4'
 ```
 
-PyPI installation becomes available when that version is published: `python -m pip install 'engineering-argument-language==3.2.3'`. See [packaging and releases](https://github.com/emmett08/earl/blob/main/docs/packaging.md) for artefact verification, supported Python imports and publication setup. Command collectors and custom reasoning methods require a POSIX host; the release workflow is configured to check distribution installation on Linux and macOS.
+PyPI installation becomes available when that version is published: `python -m pip install 'engineering-argument-language==3.2.4'`. See [packaging and releases](https://github.com/emmett08/earl/blob/main/docs/packaging.md) for artefact verification, supported Python imports and publication setup. Command collectors and custom reasoning methods require a POSIX host; the release workflow is configured to check distribution installation on Linux and macOS.
 
 Original EARL software is available under the [Unlicense](https://github.com/emmett08/earl/blob/main/LICENSE), permitting commercial and non-commercial use, modification and redistribution. Dependencies and any third-party material retain their own terms; see [licence scope](https://github.com/emmett08/earl/blob/main/docs/packaging.md#licence-scope).
 

{engineering_argument_language-3.2.3 → engineering_argument_language-3.2.4}/README.md

@@ -2,7 +2,7 @@
 
 EAL/3 records engineering claims, their evidence requirements, reasoning methods, assumptions and objections in reusable source files. A Python host binds declared tools to a separate TOML configuration, collects observations, assesses claims and stores the result. Later sessions and different models can find the same source and reuse compatible observations until they expire.
 
-The Python distribution is **`engineering-argument-language` 3.2.3** and requires Python **3.11 or later**; application code imports `eal`. The supported source language is `EAL/3`, with newline-terminated fields and typed flows. Stored tool results use `EAL/observation-record/1`; model-facing summaries use `EAL/assessment-packet/2`.
+The Python distribution is **`engineering-argument-language` 3.2.4** and requires Python **3.11 or later**; application code imports `eal`. The supported source language is `EAL/3`, with newline-terminated fields and typed flows. Stored tool results use `EAL/observation-record/1`; model-facing summaries use `EAL/assessment-packet/2`.
 
 ## Author a bounded argument
 
@@ -43,18 +43,18 @@ Create a virtual environment, then install a built or downloaded wheel:
 ```bash
 python3 -m venv .venv
 . .venv/bin/activate
-python -m pip install ./engineering_argument_language-3.2.3-py3-none-any.whl
+python -m pip install ./engineering_argument_language-3.2.4-py3-none-any.whl
 eal --help
 ```
 
-After the maintainer creates the `v3.2.3` release tag, a pinned source installation is also available:
+After the maintainer creates the `v3.2.4` release tag, a pinned source installation is also available:
 
 ```bash
 python -m pip install \
-  'engineering-argument-language @ git+https://github.com/emmett08/earl.git@v3.2.3'
+  'engineering-argument-language @ git+https://github.com/emmett08/earl.git@v3.2.4'
 ```
 
-PyPI installation becomes available when that version is published: `python -m pip install 'engineering-argument-language==3.2.3'`. See [packaging and releases](https://github.com/emmett08/earl/blob/main/docs/packaging.md) for artefact verification, supported Python imports and publication setup. Command collectors and custom reasoning methods require a POSIX host; the release workflow is configured to check distribution installation on Linux and macOS.
+PyPI installation becomes available when that version is published: `python -m pip install 'engineering-argument-language==3.2.4'`. See [packaging and releases](https://github.com/emmett08/earl/blob/main/docs/packaging.md) for artefact verification, supported Python imports and publication setup. Command collectors and custom reasoning methods require a POSIX host; the release workflow is configured to check distribution installation on Linux and macOS.
 
 Original EARL software is available under the [Unlicense](https://github.com/emmett08/earl/blob/main/LICENSE), permitting commercial and non-commercial use, modification and redistribution. Dependencies and any third-party material retain their own terms; see [licence scope](https://github.com/emmett08/earl/blob/main/docs/packaging.md#licence-scope).
 

{engineering_argument_language-3.2.3 → engineering_argument_language-3.2.4}/docs/aspic-method.md

@@ -2,7 +2,7 @@
 
 `argumentation/aspic/2` is a bounded, host-installed ASPIC+ instantiation. It constructs arguments from an explicit finite theory, derives undermining, rebutting and undercutting defeats, and computes grounded, preferred or stable extensions with a separate credulous or sceptical conclusion query. The separate, opt-in `EAL/3-compiled-aspic/5` operation translates authored EAL routes at a checked observation snapshot. EAL/3 admits reviewed `strict`, `rank`, `contrary` and `prefer` relations with targets resolved through its own declaration namespace. The default authored evaluator validates these directives without applying their inference effects. The [ASPIC+ tutorial](sources.md#argument-and-reasoning-models) supplies the framework's argument, attack and defeat definitions; the restrictions and ranking below are this implementation's choices.
 
-The Python package is 3.2.3. The compiled profile is `/5`, while the installed ASPIC method is `argumentation/aspic/2` with implementation `eal-aspic-finite-5`. Stored observations retain acquisition identities and original measurement times; returned records contain output digests and byte counts without raw process streams.
+The Python package is 3.2.4. The compiled profile is `/5`, while the installed ASPIC method is `argumentation/aspic/2` with implementation `eal-aspic-finite-5`. Stored observations retain acquisition identities and original measurement times; returned records contain output digests and byte counts without raw process streams.
 
 ## Run the synthetic engineering case
 

{engineering_argument_language-3.2.3 → engineering_argument_language-3.2.4}/docs/eal3-composition.md

@@ -1,6 +1,6 @@
 # Scoped composition in EAL/3
 
-EAL/3 package 3.2.3 retains the typed evidence, assumption, reasoning, claim, argument, objection, proposition and reviewed-directive mappings. ANTLR recognition is followed by lexical binding, hygienic expansion, typed validation, local method evaluation and a separately selected argument calculus. [The syntax comparison](eal3-syntax-comparison.md) shows original-to-EAL/3 structural mappings. [EAL.g4](../grammar/EAL.g4) is the complete grammar; generated recognisers are committed and checked against ANTLR 4.13.2.
+EAL/3 package 3.2.4 retains the typed evidence, assumption, reasoning, claim, argument, objection, proposition and reviewed-directive mappings. ANTLR recognition is followed by lexical binding, hygienic expansion, typed validation, local method evaluation and a separately selected argument calculus. [The syntax comparison](eal3-syntax-comparison.md) shows original-to-EAL/3 structural mappings. [EAL.g4](../grammar/EAL.g4) is the complete grammar; generated recognisers are committed and checked against ANTLR 4.13.2.
 
 ## Names, modules and source imports
 

{engineering_argument_language-3.2.3 → engineering_argument_language-3.2.4}/docs/eal3-design.md

@@ -15,7 +15,7 @@ This explains the design of the EAL/3 source language. Syntax, the argument solv
 
 ## Purpose and extension criterion
 
-EAL/3 is the semantic source contract, `EAL/3` identifies the current newline-based notation, and the installed Python package declares version 3.2.3. Formal reasoning-method inputs use `EAL/typed-input/1`. Source version, package version, acquisition fields, typed-method input envelope and method identifiers name different contracts. Model summaries use `EAL/assessment-packet/2` and `EAL/model-context/2`; the observation-record schema remains `/1`.
+EAL/3 is the semantic source contract, `EAL/3` identifies the current newline-based notation, and the installed Python package declares version 3.2.4. Formal reasoning-method inputs use `EAL/typed-input/1`. Source version, package version, acquisition fields, typed-method input envelope and method identifiers name different contracts. Model summaries use `EAL/assessment-packet/2` and `EAL/model-context/2`; the observation-record schema remains `/1`.
 
 The service keeps validated EAL/3 source, claim identity, compatible tool observations and checked reasoning results available across sessions and model providers. A developer can request a registered claim without sending the source, reconstructing its dependency graph or rerunning unexpired observations. A gain in correctness, time or cost remains a **hypothesis** to measure. The maintained [API load-test example](../examples/api-load-test/README.md) establishes an execution path using synthetic data.
 

{engineering_argument_language-3.2.3 → engineering_argument_language-3.2.4}/docs/mcp-and-tools.md

@@ -139,7 +139,7 @@ JSON
 
 Add `--token-env EAL_MCP_TOKEN` for an authenticated endpoint. A configured `http` transport also connects to an existing server, using the configured host, port and path; a wildcard bind such as `0.0.0.0` requires an explicit client `--url`. An explicit URL overrides the configured transport. The server's launch configuration fixes its workspace, methods and tool exposure. The host validates the flat request and the discovered input schema before invoking the remote operation. The MCP client negotiates a supported protocol profile; EAL operation identities and persisted assessment bindings are independent of that profile.
 
-The host returns one JSON response. Credential sanitisation preserves its field names and public envelope metadata (`operation`, `protocol_version`, `is_error` and content-block `type`), while replacing credential occurrences in application string values and diagnostic text with `[redacted]`. JSON encoded within content text is decoded before sanitisation so its field names also remain stable. A credential may share its spelling with a public field name; preserving that name maintains the response contract.
+The host returns one JSON response. Credential sanitisation preserves the fixed host envelope fields and the content-block fields declared by the pinned MCP SDK. Public envelope metadata (`operation`, `protocol_version`, `is_error`) and recognised content-block `type` values remain stable. Application object keys, string values, extra wrapper fields and diagnostic text replace credential occurrences with `[redacted]`, including application keys whose spelling matches a public field name. JSON encoded within text is decoded before sanitisation, including escaped keys and nested JSON strings. Text beginning with a JSON object, array or quoted string that fails strict decoding is replaced in full because its escapes cannot be safely retained. An empty string is used when the replacement marker or its surrounding text would disclose the credential. When redaction would merge distinct object keys, the host returns one error response with exit code 2 and emits no partial application result.
 
 `--timeout SECONDS` sets the host's total MCP-session deadline, defaulting to 120 seconds. In the stdio route, ending the owned server process signals its command supervisor to stop the collector group; the inherited acquisition lease remains held until cleanup finishes. An HTTP host connects to an independently running server, so its session deadline ends that client interaction. The server continues to enforce acquisition ownership and configured collector timeouts.
 

{engineering_argument_language-3.2.3 → engineering_argument_language-3.2.4}/docs/mcp-architecture.md

@@ -28,7 +28,7 @@ Registered exposure requires a non-empty entry allowlist and uses those entries'
 
 The HTTP runner explicitly enables strict Host/Origin protection. FastMCP accepts its loopback host defaults, the configured host, the actual bound address and configured host additions. It accepts same-origin requests and loopback origins on loopback requests, plus configured origin additions. Untrusted headers are rejected before MCP handling. Host/Origin trust lists contain up to 128 unique literal entries each; their validation rejects wildcards. Browser CORS response headers remain a separate deployment setting.
 
-The HTTP client constructs `BearerAuth` explicitly, keeping credentials opaque instead of interpreting token spellings as authentication modes. Host sanitisation keeps public JSON field names and envelope metadata stable and redacts application string values and diagnostic text. It parses JSON-bearing content text before redacting values, preserving the same structure in structured and text representations.
+The HTTP client constructs `BearerAuth` explicitly, keeping credentials opaque instead of interpreting token spellings as authentication modes. Host sanitisation preserves fixed envelope fields and the content-block fields declared by the pinned MCP SDK, together with public envelope metadata and recognised content discriminators. Application object keys and string values are remote data and are sanitised recursively, including JSON encoded within content text. Extra wrapper fields receive the same treatment. Strictly undecodable JSON-looking text is replaced in full; object-key collisions caused by redaction return an error instead of overwriting a value. Structured and text representations use the same application-data sanitiser.
 
 ## Execution and verification scope
 

{engineering_argument_language-3.2.3 → engineering_argument_language-3.2.4}/docs/packaging.md

@@ -1,6 +1,6 @@
 # Packaging and releases
 
-The Python distribution is `engineering-argument-language` version `3.2.3`; its import package is `eal`. It supplies the Python API, the `eal`, `eal-mcp` and `eal-host` commands, and one FastMCP server configurable for stdio or Streamable HTTP. Python 3.11 or later is required. Runtime dependencies are declared in [pyproject.toml](../pyproject.toml) and installed by pip; development dependencies are separate.
+The Python distribution is `engineering-argument-language` version `3.2.4`; its import package is `eal`. It supplies the Python API, the `eal`, `eal-mcp` and `eal-host` commands, and one FastMCP server configurable for stdio or Streamable HTTP. Python 3.11 or later is required. Runtime dependencies are declared in [pyproject.toml](../pyproject.toml) and installed by pip; development dependencies are separate.
 
 ## Install a distribution
 
@@ -9,14 +9,14 @@ Use a virtual environment. The commands below use a POSIX shell:
 ```bash
 python3 -m venv .venv
 . .venv/bin/activate
-python -m pip install ./engineering_argument_language-3.2.3-py3-none-any.whl
+python -m pip install ./engineering_argument_language-3.2.4-py3-none-any.whl
 python -m pip check
 eal --help
 eal-mcp --help
 eal-host --help
 ```
 
-Supply the path to a downloaded workflow artefact or a wheel built from the reviewed source. A downloaded workflow archive includes `dist/` and `SHA256SUMS`; from its extracted root, run `shasum -a 256 --check SHA256SUMS` before installing a file under `dist/`. A source distribution can be installed with `python -m pip install ./engineering_argument_language-3.2.3.tar.gz`; pip installs the build requirements and builds its wheel. The committed generated ANTLR parser makes Java unnecessary for ordinary installation and parsing.
+Supply the path to a downloaded workflow artefact or a wheel built from the reviewed source. A downloaded workflow archive includes `dist/` and `SHA256SUMS`; from its extracted root, run `shasum -a 256 --check SHA256SUMS` before installing a file under `dist/`. A source distribution can be installed with `python -m pip install ./engineering_argument_language-3.2.4.tar.gz`; pip installs the build requirements and builds its wheel. The committed generated ANTLR parser makes Java unnecessary for ordinary installation and parsing.
 
 For a reviewed GitHub revision, substitute its full commit SHA for `FULL_COMMIT_SHA`:
 
@@ -29,13 +29,13 @@ Git must be installed for this route. A pinned tag can replace the commit SHA af
 
 ```bash
 python -m pip install \
-  'engineering-argument-language @ git+https://github.com/emmett08/earl.git@v3.2.3'
+  'engineering-argument-language @ git+https://github.com/emmett08/earl.git@v3.2.4'
 ```
 
-The tag command requires an existing `v3.2.3` tag. PyPI installation requires publication of that version; once published, use:
+The tag command requires an existing `v3.2.4` tag. PyPI installation requires publication of that version; once published, use:
 
 ```bash
-python -m pip install 'engineering-argument-language==3.2.3'
+python -m pip install 'engineering-argument-language==3.2.4'
 ```
 
 The wheel is pure Python. Command collectors require POSIX process groups and file descriptors; bounded custom reasoning methods require POSIX resource limits. The release workflow is configured to check distribution installation on Linux with Python 3.11–3.14 and macOS with Python 3.12. Other Python/platform combinations require separate validation for the features used. Workspace coordination covers participating processes on one local filesystem; distributed replicas and network filesystems require another coordinator. See [MCP and tools](mcp-and-tools.md) for execution limits and [MCP architecture](mcp-architecture.md) for acquisition ownership.
@@ -81,7 +81,7 @@ canonical_source = format_source(source)
 
 This example checks a declaration's syntax and references. An assessment needs its authored support routes and observations. Private helpers, generated-parser classes and database tables are implementation details; integration code uses the documented interfaces. Pin a reviewed package release and consult the current contract before upgrading. This project develops the current EAL/3 language without a backwards-compatibility guarantee.
 
-Package `3.2.3` identifies this distributed implementation. `EAL/3` identifies source syntax and semantics. Schema identifiers describe different records: observations use `EAL/observation-record/1`, assessment packets use `EAL/assessment-packet/2`, and model messages use `EAL/model-context/2`. A packaging change does not itself revise those language or record contracts.
+Package `3.2.4` identifies this distributed implementation. `EAL/3` identifies source syntax and semantics. Schema identifiers describe different records: observations use `EAL/observation-record/1`, assessment packets use `EAL/assessment-packet/2`, and model messages use `EAL/model-context/2`. A packaging change does not itself revise those language or record contracts.
 
 ## Licence scope
 
@@ -128,26 +128,26 @@ Each publishing job receives `id-token: write` at job level. The PyPA action aut
 
 The initial release procedure is:
 
-1. Merge the reviewed packaging change. Ensure `pyproject.toml` and `eal.__version__` agree on `3.2.3`, then create `v3.2.3` at that reviewed commit on `main`.
+1. Merge the reviewed packaging change. Ensure `pyproject.toml` and `eal.__version__` agree on `3.2.4`, then create `v3.2.4` at that reviewed commit on `main`.
 2. Register the production Trusted Publisher with the exact identity above. Configure the repository environment `pypi.org` to permit release tags and apply any required deployment reviewers. For optional TestPyPI publication, register its separate Trusted Publisher and configure the `testpypi` environment's deployment rules. Each package index uses a pending publisher for a new project or a normal publisher for an existing project.
-3. Dispatch the workflow from the `v3.2.3` tag, with `release_tag=v3.2.3` and `destination=verify`, using the GitHub CLI command below. The workflow must first exist on the default branch. It requires a stable `vMAJOR.MINOR.PATCH` tag, checks its resolved commit and package version, and requires that commit to belong to `main`'s history.
+3. Dispatch the workflow from the `v3.2.4` tag, with `release_tag=v3.2.4` and `destination=verify`, using the GitHub CLI command below. The workflow must first exist on the default branch. It requires a stable `vMAJOR.MINOR.PATCH` tag, checks its resolved commit and package version, and requires that commit to belong to `main`'s history.
 4. Review the full check and artefact installation results, and download the retained wheel and source distribution. If TestPyPI is configured, dispatch from the same tag with `destination=testpypi` to exercise its publication path and check that release.
 5. Dispatch from the same tag with `destination=pypi` to publish the production release. Publication begins after all required verification jobs and the `pypi.org` environment's deployment rules pass.
 
 Dispatch verification with the matching tag ref and input:
 
 ```bash
-gh workflow run publish.yml --repo emmett08/earl --ref v3.2.3 \
-  -f release_tag=v3.2.3 -f destination=verify
+gh workflow run publish.yml --repo emmett08/earl --ref v3.2.4 \
+  -f release_tag=v3.2.4 -f destination=verify
 ```
 
 After verification and authentication setup, dispatch the optional TestPyPI release and the production PyPI release:
 
 ```bash
-gh workflow run publish.yml --repo emmett08/earl --ref v3.2.3 \
-  -f release_tag=v3.2.3 -f destination=testpypi
-gh workflow run publish.yml --repo emmett08/earl --ref v3.2.3 \
-  -f release_tag=v3.2.3 -f destination=pypi
+gh workflow run publish.yml --repo emmett08/earl --ref v3.2.4 \
+  -f release_tag=v3.2.4 -f destination=testpypi
+gh workflow run publish.yml --repo emmett08/earl --ref v3.2.4 \
+  -f release_tag=v3.2.4 -f destination=pypi
 ```
 
 The release workflow is configured to produce exactly one wheel and one source distribution with a SHA-256 checksum file. Linux and macOS installation jobs verify those artefacts; the publishing job verifies the checksum and consumes the same build's retained artefacts by immutable upload ID. Both publishing jobs run without checking out or installing the package. Only the publishing jobs receive `id-token: write`; build and verification jobs have read-only repository permissions. Each package index's Trusted Publisher registration must match the publishing job's repository, workflow and environment identity.
@@ -157,9 +157,9 @@ To check a published TestPyPI wheel while resolving dependencies through ordinar
 ```bash
 python -m pip download --no-deps --only-binary=:all: \
   --index-url https://test.pypi.org/simple/ --dest test-release \
-  'engineering-argument-language==3.2.3'
+  'engineering-argument-language==3.2.4'
 python -m pip install \
-  ./test-release/engineering_argument_language-3.2.3-py3-none-any.whl
+  ./test-release/engineering_argument_language-3.2.4-py3-none-any.whl
 python -m pip check
 ```
 

{engineering_argument_language-3.2.3 → engineering_argument_language-3.2.4}/examples/api-load-test/README.md

@@ -117,7 +117,7 @@ JSON
 
 The result describes EAL/3 and includes `engineering/api-load-criteria/1`. Subsequent requests can use `validate`, `collect`, `reason`, `explain` and `compile_aspic` with their documented fields. In the stdio route, `eal-host --config examples/api-load-test/mcp.toml` launches its subprocess with the same service settings. Each server process selects one transport; the database and observation identities remain shared when both launches use this local workspace.
 
-The example binds HTTP to loopback and uses operator exposure. Host and Origin validation is always enabled. Configure a named token environment variable for authenticated HTTP; a non-loopback bind or an additional non-loopback trust entry requires it. Public proxies need their client-facing hostname in `allowed_hosts`, and a trusted browser application on a separate origin needs its HTTP(S) origin in `allowed_origins`. The supplied configuration includes commented examples. [MCP and tools](../../docs/mcp-and-tools.md) documents precedence, access scope and concurrency. Shared local launches coordinate initial database setup, and command supervision retains acquisition exclusion through collector cleanup if an owned stdio server stops. HTTP serving changes how clients reach the synthetic assessment; its availability supplies no measurements of production performance.
+The example binds HTTP to loopback and uses operator exposure. Host and Origin validation is always enabled. Configure a named token environment variable for authenticated HTTP; a non-loopback bind or an additional non-loopback trust entry requires it. Public proxies need their client-facing hostname in `allowed_hosts`, and a trusted browser application on a separate origin needs its HTTP(S) origin in `allowed_origins`. The supplied configuration includes commented examples. The host sanitises credential occurrences in application object keys and string values, including JSON encoded within content text, while retaining fixed response wrappers. A collision between sanitised keys produces an error instead of discarding a measurement. [MCP and tools](../../docs/mcp-and-tools.md) documents precedence, access scope and concurrency. Shared local launches coordinate initial database setup, and command supervision retains acquisition exclusion through collector cleanup if an owned stdio server stops. HTTP serving changes how clients reach the synthetic assessment; its availability supplies no measurements of production performance.
 
 ## Reuse the registered argument across sessions
 

{engineering_argument_language-3.2.3 → engineering_argument_language-3.2.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "engineering-argument-language"
-version = "3.2.3"
+version = "3.2.4"
 description = "An ANTLR4 language and MCP interpreter for engineering reasoning and argumentation"
 readme = "README.md"
 license = "Unlicense"

{engineering_argument_language-3.2.3 → engineering_argument_language-3.2.4}/scripts/distribution_smoke.py

@@ -14,6 +14,7 @@ import time
 
 import eal
 from eal.formatter import format_source
+from eal.host_redaction import sanitise_response
 from eal.knowledge import EALKnowledgeBase, ModelContextAdapter
 from eal.parser import parse
 from eal.runtime import ReasoningService
@@ -108,6 +109,19 @@ def main() -> None:
     assert Path(eal.__file__).resolve().is_relative_to(Path(sys.prefix).resolve()), eal.__file__
     assert eal.__version__ == arguments.expected_version
     assert importlib.metadata.version("engineering-argument-language") == arguments.expected_version
+    token = 'synthetic\\"bearer-key'
+    payload = {"nested": [{token: token}]}
+    sanitised = sanitise_response(
+        {"result": payload, "content": [{"type": "text", "text": json.dumps(payload)}]}, token,
+    )
+    assert sanitised["result"] == {"nested": [{"[redacted]": "[redacted]"}]}
+    assert json.loads(sanitised["content"][0]["text"]) == sanitised["result"]
+    try:
+        sanitise_response({"result": {token: "first", "[redacted]": "second"}}, token)
+    except ValueError as exc:
+        assert token not in str(exc)
+    else:
+        raise AssertionError("Installed redactor silently merged object keys")
     assert validate(parse(SOURCE)) == []
     assert validate(parse(format_source(SOURCE))) == []
 

{engineering_argument_language-3.2.3 → engineering_argument_language-3.2.4}/src/eal/__init__.py

@@ -1,3 +1,3 @@
 """Engineering Argument Language: explicit, revisable engineering reasoning."""
 
-__version__ = "3.2.3"
+__version__ = "3.2.4"

engineering_argument_language-3.2.4/src/eal/host_redaction.py

@@ -0,0 +1,90 @@
+"""Sanitise remote JSON keys and values while retaining fixed host wrappers."""
+
+from __future__ import annotations
+
+import json
+from typing import Any
+
+from mcp.types import AudioContent, EmbeddedResource, ImageContent, ResourceLink, TextContent
+
+from .tool_acquisition import strict_json
+
+
+_HOST_FIELDS = frozenset({"operation", "protocol_version", "is_error", "result", "content", "error"})
+_HOST_METADATA = frozenset({"operation", "protocol_version", "is_error"})
+# Only fields declared by the pinned MCP models are public wrapper names.
+# Extra fields and keys inside application payloads remain remote data.
+_CONTENT_FIELDS = {
+    model.model_fields["type"].default: frozenset(model.model_fields) | frozenset(
+        field.alias for field in model.model_fields.values() if field.alias
+    )
+    for model in (TextContent, ImageContent, AudioContent, ResourceLink, EmbeddedResource)
+}
+
+
+def _replacement(token: str) -> str:
+    # An opaque credential may itself be the conventional marker or part of it.
+    return "" if token in "[redacted]" else "[redacted]"
+
+
+def _redact_text(value: str, token: str) -> str:
+    sanitised = value.replace(token, _replacement(token))
+    # Adjacent text can reconstruct the credential around a replacement marker.
+    return "" if token in sanitised else sanitised
+
+
+def _redact_object(value: dict[str, Any], token: str, *, public_keys: frozenset[str] = frozenset(),
+                   public_values: frozenset[str] = frozenset()) -> dict[str, Any]:
+    sanitised = {}
+    for key, item in value.items():
+        field = key if key in public_keys else _redact_text(key, token)
+        if field in sanitised:
+            raise ValueError("Credential redaction would merge distinct JSON object keys")
+        sanitised[field] = item if key in public_values else _redact(item, token)
+    return sanitised
+
+
+def _redact(value: Any, token: str) -> Any:
+    """Decode nested JSON representations before sanitising application data."""
+    if isinstance(value, str):
+        try:
+            decoded = strict_json(value)
+        except ValueError:
+            # Unsafe JSON (including duplicate keys) can conceal an escaped
+            # credential. Preserve no partially sanitised representation.
+            if value.lstrip().startswith(("{", "[", '"')):
+                return _replacement(token)
+            decoded = None
+        if isinstance(decoded, (dict, list, str)):
+            sanitised = _redact(decoded, token)
+            if sanitised == decoded:
+                return value
+            return json.dumps(sanitised, ensure_ascii=False, allow_nan=False)
+        return _redact_text(value, token)
+    if isinstance(value, list):
+        return [_redact(item, token) for item in value]
+    if isinstance(value, dict):
+        return _redact_object(value, token)
+    return value
+
+
+def sanitise_response(response: dict[str, Any], token: str | None) -> dict[str, Any]:
+    """Keep fixed wrappers stable; refuse redaction that would merge object keys."""
+    if not token:
+        return response
+    content = response.get("content")
+    public_values = _HOST_METADATA | {"content"} if isinstance(content, list) else _HOST_METADATA
+    sanitised = _redact_object(response, token, public_keys=_HOST_FIELDS, public_values=public_values)
+    if isinstance(content, list):
+        sanitised["content"] = []
+        for block in content:
+            if isinstance(block, dict):
+                kind = block.get("type")
+                fields = _CONTENT_FIELDS.get(kind) if isinstance(kind, str) else None
+                sanitised["content"].append(_redact_object(
+                    block, token, public_keys=fields or frozenset({"type"}),
+                    public_values=frozenset({"type"}) if fields else frozenset(),
+                ))
+            else:
+                sanitised["content"].append(_redact(block, token))
+    return sanitised

{engineering_argument_language-3.2.3 → engineering_argument_language-3.2.4}/src/engineering_argument_language.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: engineering-argument-language
-Version: 3.2.3
+Version: 3.2.4
 Summary: An ANTLR4 language and MCP interpreter for engineering reasoning and argumentation
 Author: Emmett Miller
 Maintainer: Emmett Miller
@@ -41,7 +41,7 @@ Dynamic: license-file
 
 EAL/3 records engineering claims, their evidence requirements, reasoning methods, assumptions and objections in reusable source files. A Python host binds declared tools to a separate TOML configuration, collects observations, assesses claims and stores the result. Later sessions and different models can find the same source and reuse compatible observations until they expire.
 
-The Python distribution is **`engineering-argument-language` 3.2.3** and requires Python **3.11 or later**; application code imports `eal`. The supported source language is `EAL/3`, with newline-terminated fields and typed flows. Stored tool results use `EAL/observation-record/1`; model-facing summaries use `EAL/assessment-packet/2`.
+The Python distribution is **`engineering-argument-language` 3.2.4** and requires Python **3.11 or later**; application code imports `eal`. The supported source language is `EAL/3`, with newline-terminated fields and typed flows. Stored tool results use `EAL/observation-record/1`; model-facing summaries use `EAL/assessment-packet/2`.
 
 ## Author a bounded argument
 
@@ -82,18 +82,18 @@ Create a virtual environment, then install a built or downloaded wheel:
 ```bash
 python3 -m venv .venv
 . .venv/bin/activate
-python -m pip install ./engineering_argument_language-3.2.3-py3-none-any.whl
+python -m pip install ./engineering_argument_language-3.2.4-py3-none-any.whl
 eal --help
 ```
 
-After the maintainer creates the `v3.2.3` release tag, a pinned source installation is also available:
+After the maintainer creates the `v3.2.4` release tag, a pinned source installation is also available:
 
 ```bash
 python -m pip install \
-  'engineering-argument-language @ git+https://github.com/emmett08/earl.git@v3.2.3'
+  'engineering-argument-language @ git+https://github.com/emmett08/earl.git@v3.2.4'
 ```
 
-PyPI installation becomes available when that version is published: `python -m pip install 'engineering-argument-language==3.2.3'`. See [packaging and releases](https://github.com/emmett08/earl/blob/main/docs/packaging.md) for artefact verification, supported Python imports and publication setup. Command collectors and custom reasoning methods require a POSIX host; the release workflow is configured to check distribution installation on Linux and macOS.
+PyPI installation becomes available when that version is published: `python -m pip install 'engineering-argument-language==3.2.4'`. See [packaging and releases](https://github.com/emmett08/earl/blob/main/docs/packaging.md) for artefact verification, supported Python imports and publication setup. Command collectors and custom reasoning methods require a POSIX host; the release workflow is configured to check distribution installation on Linux and macOS.
 
 Original EARL software is available under the [Unlicense](https://github.com/emmett08/earl/blob/main/LICENSE), permitting commercial and non-commercial use, modification and redistribution. Dependencies and any third-party material retain their own terms; see [licence scope](https://github.com/emmett08/earl/blob/main/docs/packaging.md#licence-scope).
 

{engineering_argument_language-3.2.3 → engineering_argument_language-3.2.4}/src/engineering_argument_language.egg-info/SOURCES.txt

@@ -300,6 +300,7 @@ tests/test_frontend_contract_review.py
 tests/test_host.py
 tests/test_host_credentials.py
 tests/test_host_limits.py
+tests/test_host_redaction.py
 tests/test_http_origin.py
 tests/test_investigation_improvements.py
 tests/test_knowledge.py

{engineering_argument_language-3.2.3 → engineering_argument_language-3.2.4}/tests/test_host_credentials.py

@@ -38,16 +38,16 @@ async def invoke_host(url: str, token: str, source: str, workspace: Path):
 
 
 @pytest.mark.parametrize("token", ["oauth", "is_error", "result", "operation", "validate", "text"])
-def test_http_host_preserves_envelope_and_nested_schema_on_success_and_tool_failure(tmp_path, token):
+def test_http_host_preserves_envelope_and_redacts_remote_keys_on_success_and_tool_failure(tmp_path, token):
     class CredentialEchoService(ReasoningService):
         def validate(self, source):
             if source == "failure":
                 raise ValueError("Remote diagnostic echoed credential=" + token)
             return {
                 "valid": True,
-                "result": {"operation": token, "is_error": False,
-                           "nested": [{"result": token}]},
-                "encoded": json.dumps({"result": {"operation": token}}),
+                "echoes": {token: "key echo", "secret": token,
+                           "nested": [{"prefix-" + token + "-suffix": token}]},
+                "encoded": json.dumps({token: token}),
             }
 
     server = create_server(CredentialEchoService(tmp_path), auth=BearerTokenVerifier(token))
@@ -63,12 +63,12 @@ def test_http_host_preserves_envelope_and_nested_schema_on_success_and_tool_fail
             assert response["is_error"] is False
             expected = {
                 "valid": True,
-                "result": {"operation": "[redacted]", "is_error": False,
-                           "nested": [{"result": "[redacted]"}]},
+                "echoes": {"[redacted]": "key echo", "secret": "[redacted]",
+                           "nested": [{"prefix-[redacted]-suffix": "[redacted]"}]},
             }
             payload = response["result"]
             assert {key: payload[key] for key in expected} == expected
-            assert json.loads(payload["encoded"]) == {"result": {"operation": "[redacted]"}}
+            assert json.loads(payload["encoded"]) == {"[redacted]": "[redacted]"}
             for block in response["content"]:
                 if block["type"] == "text":
                     assert json.loads(block["text"]) == payload
@@ -104,15 +104,18 @@ def test_http_host_preserves_failure_envelope_without_disclosing_credential(tmp_
     asyncio.run(exercise())
 
 
-@pytest.mark.parametrize("token", ["operation", "is_error", "result", "2026-07-28"])
-def test_public_response_metadata_is_stable_when_it_coincides_with_a_credential(token):
+@pytest.mark.parametrize(("token", "application_key"), [
+    ("operation", "result"), ("is_error", "result"),
+    ("result", "[redacted]"), ("2026-07-28", "result"),
+])
+def test_public_response_metadata_is_stable_when_it_coincides_with_a_credential(token, application_key):
     response = {"operation": "operation", "protocol_version": "2026-07-28",
                 "is_error": False, "result": {"result": token}}
     sanitised = sanitise_response(response, token)
     assert sanitised["operation"] == response["operation"]
     assert sanitised["protocol_version"] == response["protocol_version"]
     assert sanitised["is_error"] is False
-    assert sanitised["result"] == {"result": "[redacted]"}
+    assert sanitised["result"] == {application_key: "[redacted]"}
 
 
 def test_json_text_decodes_escaped_credentials_before_value_redaction():
@@ -130,7 +133,30 @@ def test_json_string_text_decodes_escaped_credentials_before_value_redaction():
     assert json.loads(sanitised["content"][0]["text"]) == "[redacted]"
 
 
-def test_json_text_with_only_a_schema_key_collision_keeps_its_representation():
+def test_json_text_redacts_an_application_key_even_when_it_matches_a_public_field():
     encoded = '{\n  "result": true\n}'
     response = {"content": [{"type": "text", "text": encoded}]}
-    assert sanitise_response(response, "result") == response
+    sanitised = sanitise_response(response, "result")
+    assert json.loads(sanitised["content"][0]["text"]) == {"[redacted]": True}
+
+
+def test_http_host_refuses_key_collisions_without_emitting_partial_results(tmp_path):
+    token = "synthetic-collision-token"
+
+    class CollidingService(ReasoningService):
+        def validate(self, source):
+            return {token: "first", "[redacted]": "second"}
+
+    server = create_server(CollidingService(tmp_path), auth=BearerTokenVerifier(token))
+
+    async def exercise():
+        async with run_server_async(server) as url:
+            completed = await invoke_host(url, token, "success", tmp_path)
+            assert completed.returncode == 2
+            assert token not in completed.stdout
+            assert json.loads(completed.stdout) == {
+                "is_error": True,
+                "error": "Credential redaction would merge distinct JSON object keys",
+            }
+
+    asyncio.run(exercise())