accountable-surface 0.3.1__tar.gz

accountable_surface-0.3.1/.gitignore

@@ -0,0 +1,20 @@
+# secrets / env (never commit)
+.env
+.env.*
+!.env.example
+CLAUDE.local.md
+
+# python
+__pycache__/
+*.py[cod]
+*.egg-info/
+build/
+dist/
+.pytest_cache/
+.venv/
+venv/
+
+# IO-boundary cache + runtime operator journals (operator-supplied, not source)
+.warden-safe-cache/
+*.session.jsonl
+journals/

accountable_surface-0.3.1/AGENTS.md

@@ -0,0 +1,48 @@
+# AGENTS.md -- Accountable Surface
+
+## Project Boundary
+
+Accountable Surface is a public Python workbench for witnessed perception,
+operator-granted action, verification, journals, and MCP integration. It is a
+controlled local action surface: grants are loaded by the operator, actions are
+bounded by effectors, and verification happens after each permitted action.
+
+## Public Delivery Rules
+
+- Keep `README.md`, `USAGE.md`, `CHANGELOG.md`, `CONTRIBUTING.md`, `AUTHORS.md`,
+  `LICENSE`, `.github/FUNDING.yml`, `.github/workflows/ci.yml`, examples, docs,
+  web demos, and package metadata aligned.
+- Public claims must be backed by tests, examples, specs, or reproducible
+  commands.
+- Do not commit `.env` files, private grants, journals, local caches, raw
+  transcripts, credentials, or private corpus material.
+- Keep the README clear for two audiences: public users deciding what the tool
+  does, and developers trying to run or extend it.
+
+## Developer Verification
+
+From this repo, with sibling checkouts available:
+
+```powershell
+$env:PYTHONPATH = "src;..\coherence-membrane\src;..\proof-surface\src"
+python -m pip install -e ".[test]"
+python -m pytest
+node --test web/*.test.mjs
+```
+
+If a change touches MCP serving, run the server smoke path with the `[server]`
+extra. If a change touches actuation, add or update a test that proves the
+grant, effect, verification, rollback, or refusal behavior.
+
+If a change touches what a remote caller can reach, add or update a test in
+`tests/test_mcp_actuate.py` proving the registry refuses an unexposed action kind
+before any grant is read.
+
+If a change touches the Windows escalation ladder (`uia.py`, `uia_effector.py`,
+`uia_transport.py`), add or update a test proving verification re-reads the window
+rather than reading the instrument's own report of its work. That instrument answers
+`ok` for an act it merely dispatched.
+
+If a change touches the escalator, add or update a test proving a rung that fell does
+not set the answer. The perception a deeper rung returns carries a full digest and a
+perceptual hash, which is exactly what makes it tempting to read as a result.

accountable_surface-0.3.1/AUTHORS.md

@@ -0,0 +1,3 @@
+# Authors
+
+- Zain Dana Harper

accountable_surface-0.3.1/CHANGELOG.md

@@ -0,0 +1,186 @@
+# Changelog
+
+## 0.3.1 - 2026-09-22
+
+- Declares the runtime dependencies. The wheel previously installed cleanly and
+  then raised `ModuleNotFoundError` on first import, because `coherence-membrane`
+  and `proof-surface` were omitted while neither was published. Both are on PyPI
+  now, so both are declared. `mcp` stays optional under `[server]`.
+- Adds an OIDC trusted-publishing release workflow with tag/version, artifact
+  digest, clean-venv entry-point resolution, and sdist-rebuild gates.
+- Aligns the declared version with the repository's tag history. `pyproject.toml`
+  and `accountable_surface.__version__` both read `0.1.0` through the v0.1.0,
+  v0.2.1 and v0.3.0 tags, so the MCP `serverInfo` reported `0.1.0` to every
+  client regardless of which release was running. A new guard binds the two.
+
+## Unreleased
+
+- Interoperable MCP server for the accountable-actuation core
+  (`accountable_surface.interop_mcp` + `interop_runtime`). A zero-third-party-dependency
+  JSON-RPC-over-stdio server (stdlib framing, no FastMCP) so other harnesses -- Claude
+  Code, Codex, Cursor, and the Flywheel bundled lane -- adopt one seam. Exposes the six
+  accountable primitives (`perceive`, `propose`/gate, `actuate`, `journal`, `receipt`)
+  plus the shipped read-only verb `device_ls`, and `status`/`doctor`. Console script
+  `accountable-surface-mcp`. Identity and health answer even where the runtime is not
+  installed; the action tools import it lazily and return a named error otherwise.
+- Interop manifests under `interop/`: a Claude Code `.mcp.json` server entry, a generic
+  MCP server descriptor, a Flywheel lane entry, and an "add this to your harness" README
+  for Codex and Cursor. Concise overview and an evidence-bound comparison over ungated
+  computer use in `docs/interop-mcp.md`.
+- Hard exclusions are enforced at the server boundary and asserted by test
+  (`tests/test_interop_exclusions.py`): CAPTCHA solving, anti-bot stealth / fingerprint
+  patching, reCAPTCHA token harvest, and mass or obfuscated authenticated outreach are
+  unreachable through any tool. The `SAFE_READ_VERBS` allowlist stays the boundary;
+  `EXCLUDED_CAPABILITIES` is the explicit second assertion of it. Shippable today: the
+  read-only `device ls` slice. Target, not shipped: write-class actuation and broad
+  browser / app / device breadth.
+- Not a public capability release; prepared on a branch for review.
+
+- Native-control bridge (first accountable-computer-use slice, capability-gated).
+  Gates one telos native-control verb, `device ls`, through the full loop: perceive,
+  preview, gate, act via a Node subprocess, re-perceive, verify, journal. New
+  modules `native_control_effector.py` (`NativeControlListEffector`,
+  `NativeControlRunner`, `FakeNativeControlRunner`, and a write-class contract stub
+  `NativeControlWriteEffector`) and `action_receipt.py` (`ActionReceiptReceptor`,
+  `receipt_from_outcome`, `verify_receipts`), the first runtime writer of a
+  `project-telos.action-receipt/v1` event.
+- Independent-witness verify: the effector checks the actuator's directory listing
+  against the surface's own `os.scandir`, so a wrong or lying listing fails verify
+  (false-success control) rather than passing on the actor's own account.
+- Offline receipt verifier `verify_action_receipts.py` (zero-dependency, stdlib
+  only): a receipt store re-derives to MATCH; any edited, deleted, or reordered
+  receipt yields DRIFT.
+- Safe subset only. The runner refuses any verb outside a read allowlist by
+  construction; the evasion and mass-outreach verbs and the mutating device verbs
+  are unreachable through the bridge, asserted by test. See
+  `docs/native-control-bridge.md` for the wired-vs-target status and the write-class
+  compensation contract (defined, not yet exercised).
+- Not a public capability release; prepared on a branch for review.
+
+## 0.2.0 - 2026-09-18
+
+- Added optional SQLite authority state for remote MCP actuation: durable
+  revocation, atomic finite-use reservations, idempotency, and local recovery
+  commands. Unresolved reservations remain unavailable until operator recovery.
+- With durable authority enabled, protected grant, journal, and state paths are
+  refused before access, including resolvable aliases and existing hardlinks.
+  This does not provide race-proof path access or rollback detection without an
+  external protected anchor. See `docs/durable-authority.md` for configuration
+  and the tested boundaries.
+- Bug fix: remote `perceive`, `session_journal`, and `actuate` now require
+  explicit scoped read grants. Remote writes fail closed unless their required
+  before/backup/after/rollback read phases match a known filesystem or API
+  target contract, and grants are reloaded just before mutation.
+- Bug fix: `actuate(expected_digest=...)` now refuses before effect when the
+  supplied precondition cannot be bound to an explicit observation identity, and
+  filesystem/API/browser preconditions reach the gate as state checks instead of
+  silently becoming `not-applicable`.
+- Limit: this does not harden filesystem TOCTOU/symlink races, interrupt
+  revocation mid-method, or gate local `surface.actuate()` reads.
+
+## 2026-09-13 - First Release Recovery
+
+- Refreshed the README verification block from the old `3e4b342` checkpoint to
+  current public `main` at `a0bafe6`.
+- Added the first-release checklist in `docs/RELEASE.md`: it records the exact
+  test, build, Twine, and proof-install commands for a GitHub source release and
+  optional package-registry upload.
+- Publication remains a separate reviewed action. This update prepares evidence
+  and documentation; it does not create a tag, GitHub release, PyPI project, or
+  registry upload.
+
+## 2026-09-05 - The Escalator That Records Why It Fell
+
+- Added `escalator.py`: rungs are climbed in cost order and each fall is recorded with
+  the reason that justified paying for the next one. `Ascent.trace()` prints the whole
+  climb, one line per rung.
+- A question travels the ladder, not a plan. Each probe restates it in its own nouns or
+  declines, which keeps the rungs from acquiring a shared verb vocabulary they do not
+  have.
+- A rung that fell never sets the answer. When the ladder runs out the ascent is
+  NEEDS_HUMAN, carries `rederivable = "none"`, and hands over the perception from the
+  deepest rung that produced one.
+- Added `StructureProbe` (rung 0) and `PixelProbe` (rung 3). A whole control tree
+  settles absence as a result; a clipped one falls instead. Pixels never resolve a
+  label, and the decline is the probe's honest outcome.
+- Rungs 1 and 2 carry no probe. An escalator that acted to find something out would be
+  an actuation no grant authorized, and a test asserts a full climb sends nothing but
+  read verbs.
+- Added a false-success control for the ladder: a rung-3 sight with a content digest, a
+  perceptual hash, and a coarse description reads like an answer and settles nothing.
+
+## 2026-09-05 - An Escalation Ladder For Windows Applications
+
+- Added `UiaStructureOrgan` (rung 0): reads a window's control tree through a driver
+  and witnesses only what re-derives by name and role. A walk that had to clip the
+  tree reads UNVERIFIED, because a partial tree cannot establish that a control is
+  absent.
+- Added `UiaEffector` (rung 1): invokes or sets one control inside one window, under
+  the same effector contract as the other five. The construction bound is the window
+  title, the journal records it, and a target naming a second window is refused
+  before anything is touched.
+- An `invoke` cannot be undone, so the caller declares what should follow it
+  (`appears`, `disappears`, `value_is`) and a plan without one is refused at preview
+  time. `set_value` is the reversible intent: the prior value is read before the
+  write and put back when verification fails.
+- Verification re-reads the window. The instrument answers `ok` for an act it
+  dispatched, which says nothing about what the application did with it, so its own
+  account is never consulted. Two false-success controls hold that line.
+- Added `uia_transport.PowerShellUiaDriver`, which refuses the blind keystroke verbs
+  `input` and `type` by name before it spawns anything. Honest null: the subprocess
+  path has no test coverage; `FakeUiaDriver` drives the whole path offline instead.
+- `uia` is refused by name over MCP. It acts on a window belonging to whoever is at
+  the machine, and reaching that from off the machine is a separate decision.
+- `scope.allowed_bounds` now treats the window facet as a set, so a grant naming
+  several windows covers an effector built for any one of them.
+
+## 2026-09-05 - Actuation Over MCP Behind A Capability Registry
+
+- Added the `actuate` MCP tool. A remote caller now closes the whole loop: perceive
+  the target, plan, check the operator's gate, act, re-perceive, verify against the
+  plan, and roll back a reversible action that did not verify.
+- Added `registry.load_effectors`. The operator names a JSON spec file in
+  `ACCOUNTABLE_SURFACE_EFFECTORS` and gets exactly the effectors it lists. With the
+  variable unset nothing is actuable over MCP, whatever the grants say.
+- The spec file refuses `command`, `browser`, and `web` by name, each with the
+  reason. `doctor` reports every entry it turned down, so an empty registry never
+  leaves a typo looking like a deliberate choice.
+- The server reads the registry before the grants, so an action kind the operator
+  never exposed causes no grant read and no journal entry.
+- A caller's receipt carries the journal entry for its own action and nothing else
+  from the journal. A refusal has the same shape as a success, so a caller cannot
+  read success out of the structure of the response.
+- Honest null: when more than one loaded grant names the action kind, the first one
+  runs and the receipt says that it did.
+
+## 2026-09-05 - API Actuation And False-Success Controls
+
+- Added `ApiEffector`: writes through one declared third-party API under the
+  effector contract, named by intent rather than by route. The service allowlist
+  bounds method, host, and path shape; the gate allow must be bound to the exact
+  plan; verification re-reads the resource instead of trusting the response.
+- Added `credentials.require_secret` / `has_secret`: a credential is read from the
+  environment at call time, refused if it carries a newline, and never reaches a
+  Plan, an Observation, the journal, or an error message.
+- Added `api_transport.UrllibApiDriver`, a stdlib transport with no policy of its
+  own. Honest null: it has no test coverage, because exercising it needs a network
+  and a real credential.
+- Added `tests/test_false_success.py`: one control per shipped effector, each
+  deliberately producing a wrong result a passing verify could accept.
+- Added `scope.allowed_bounds`, so a grant can bound an effector's reach and not
+  only the action kind.
+
+## 2026-06-29 - Public And Developer Delivery Contract
+
+- Added `AGENTS.md`, `USAGE.md`, `CHANGELOG.md`, and a forward-delivery spec.
+- Added GitHub Actions CI with sibling checkouts for `coherence-membrane` and
+  `proof-surface`, Python tests, and web JavaScript tests.
+- Updated README developer guidance and package URLs.
+- Normalized scanner-blocking dash punctuation across public docs, examples,
+  tests, source comments, and web strings.
+
+## Current Status
+
+- Runtime: Python 3.10+ package with stdlib-first core and optional MCP server.
+- Surfaces: Python API, examples, web demos, MCP server, docs, tests, and CI.
+- Verification: pytest suite, Node web tests, public surface sweep.

accountable_surface-0.3.1/CLAUDE.md

@@ -0,0 +1,86 @@
+# CLAUDE.md -- Accountable Surface
+
+A live seam where a model perceives and acts only through accountability:
+witnessed perception (coherence-membrane) + a pre-execution gate (proof-surface)
++ a tamper-evident, durable journal -- under human stewardship.
+
+## Doctrine (non-negotiable)
+
+- Perception is **witnessed** (provenance digest + a falsifiable selftest), never a screenshot.
+- **Awareness is not authority** -- the model never supplies its own authorization;
+  only operator-loaded grants gate actions; no grant → default-deny.
+- Actuation is **built and gated** (not inert): `propose` is advisory and never
+  executes, while `actuate` closes the loop through an effector that acts **only on
+  a gate `allow`** for that exact plan, bounded by the operator grant, and **verifies
+  its own work** by re-perceiving the result against the intended post-condition.
+  Shipped effectors: `FilesystemEffector`, `CommandEffector` (allowlist-only, argv,
+  `shell=False`), `WebEffector`, `BrowserEffector`, `ApiEffector` (one declared
+  service, intent-named operations, official API only), `UiaEffector` (one window,
+  one control named by its accessible label). An irreversible path (e.g. an
+  `os.run` that cannot be undone) escalates to `needs-human` unless the operator
+  explicitly passes `allow_irreversible`; the effector's construction-bound refuses
+  even on a gate `allow` it was not built for. `needs-human` maps to UNVERIFIABLE,
+  never rounded up.
+- The **grant** can bound the effector's reach, not only the action kind. An
+  effector declares its construction bound through `bound()`, the journal records
+  that bound on every actuation, and a grant carrying `scope.allowed_bounds` refuses
+  an effector built wider than what the operator granted. Absent that field the grant
+  says nothing about reach, which is an honest null rather than enforcement.
+- Reaching an effector from **off the machine** takes two operator decisions, and
+  both have to agree. The registry (`ACCOUNTABLE_SURFACE_EFFECTORS`) says which
+  effectors a remote caller can reach at all, and it is empty unless the operator
+  names a spec file. The grant says what may be done with one. Neither widens the
+  other, so an exposed effector with no matching grant still denies. The server reads
+  the registry first, so an action kind the operator never exposed is refused before
+  any grant is consulted and before any attempt reaches the journal. The registry
+  refuses `command`, `browser`, `web`, and `uia` by name, and `doctor` reports every
+  spec entry it turned down, so a typo cannot read as an operator who exposed nothing
+  on purpose. `allow_irreversible` is absent from the remote path by construction: no
+  argument a caller can pass reaches it. A caller's receipt carries the journal entry
+  for its own action and no other part of the journal.
+- Reaching a Windows application runs through an **escalation ladder** rather than
+  straight to pixels. Rung 0 (`UiaStructureOrgan`) reads the window's control tree and
+  witnesses only what re-derives by name and role. Rung 1 (`UiaEffector`) acts on one
+  control by its accessible label. Rung 2 is the allowlisted argv of `CommandEffector`
+  and rung 3 is pixel perception in `world/sight.py`. Each rung has its own nouns, so a
+  plan written for one cannot be carried down to another. The ordering is proposed and
+  unmeasured: that rung 0 is cheaper than rung 3 is a claim about what each instrument
+  returns, not a timing. Two listings read UNVERIFIED and cannot establish that a
+  control is absent: a truncated tree, and an opaque one where the walk finished and
+  nothing it saw carried a name. The second is the dangerous case, since nothing
+  about it looks partial. `uia.ps1` states `settlesAbsence` and the organ derives the
+  same bit from the facts; the instrument's claim can veto a settled read and can
+  never grant one.
+- The **escalator** (`escalator.py`) chooses between the rungs and records why it fell.
+  A QUESTION travels down the ladder, never a plan, and each probe restates it in its
+  own nouns or declines with a reason. A rung that fell never sets the answer: when the
+  ladder runs out, the ascent is NEEDS_HUMAN carrying the trace and whatever perception
+  the deepest rung produced. A negative is settled only from a listing that settles
+  absence, and the trace says which of the two ways it failed to. A rung-3 sight has
+  a content digest and a perceptual hash and still answers no structural question.
+  The escalator only reads; acting stays with the effectors and their grants.
+- Every effector carries a **false-success control**: a test that deliberately
+  produces a wrong result a passing verify could accept, asserting the verdict is not
+  a pass (`tests/test_false_success.py`). Where a verify still reads the actor's own
+  account rather than an independent witness, that limit is written down beside it.
+- A **credential** is named, never held. It lives in an environment variable, is read
+  by `require_secret` at the moment of the call, and travels in a request header. It is
+  refused if it would reach the URL, because the URL is what the journal witnesses. The
+  agent hands in an intent, so it cannot name a secret, set a header, choose a host, or
+  read a token back.
+- Append-only journal; the self-view is content-addressed and cannot silently drift.
+
+## Boundaries
+
+- No secrets in the repo. Operator grants/journals are paths supplied at runtime,
+  never committed.
+- This repo does **not** touch released ORCA, and is **not** the quarantined
+  semantic-modulation corridor -- keep those separate.
+
+## Dev
+
+- `PYTHONPATH="<cm>/src;<ps>/src" python -m pytest` (pytest adds `./src`) -- 504 tests (1 skipped).
+- coherence-membrane must include `WebDocumentOrgan` (branch
+  `feat/web-and-external-organs` or later).
+- Quality gates: no file > 300 lines, no function > 50 lines, every test asserts
+  something meaningful, all tests pass before committing.

accountable_surface-0.3.1/CONTRIBUTING.md

@@ -0,0 +1,10 @@
+# Contributing
+
+This repository is part of the Project Telos public surface. Keep changes small, tested, and easy for public users and developers to verify.
+
+Before sending a change:
+
+- Read `README.md` and any local `AGENTS.md` instructions.
+- Run the narrowest test or verification command that covers the change.
+- Keep examples, package metadata, and public claims aligned with current behavior.
+- Do not commit secrets, `.env` files, private corpus material, or generated caches.

accountable_surface-0.3.1/CREDO.md

@@ -0,0 +1,23 @@
+# The Credo
+
+One belief, held steady across every tool in the family. The canonical,
+content-addressed copy is served by the Flywheel engine at `GET /api/credo`;
+this file echoes it.
+
+Flywheel and its tool family hold one belief steady across every surface:
+
+1. Knowledge is an open surface for anyone who can attain the means;
+   we build to lower the means.
+2. The work speaks for itself: an external check decides acceptance;
+   never reputation, never the model.
+3. Every result carries a receipt a stranger can re-run.
+4. No claim without its interval; the honest null is a first-class result.
+5. Ownership is earned by comprehension: you own what you can review,
+   explain, and defend.
+6. Learning is woven into the work: every flagged gap is a lesson about
+   your own system.
+7. The badge and the contribution were bundled; we rebundle them around
+   the work, not the worker.
+
+Growth, learning, knowledge, application, ownership: in that order,
+for everyone.

accountable_surface-0.3.1/LICENSE

@@ -0,0 +1,110 @@
+# Functional Source License, Version 1.1, MIT Future License
+
+## Abbreviation
+
+FSL-1.1-MIT
+
+## Notice
+
+Copyright 2026 Zain Dana Harper
+
+## Terms and Conditions
+
+### Licensor ("We")
+
+The party offering the Software under these Terms and Conditions.
+
+### The Software
+
+The "Software" is each version of the software that we make available under
+these Terms and Conditions, as indicated by our inclusion of these Terms and
+Conditions with the Software.
+
+### License Grant
+
+Subject to your compliance with this License Grant and the Patents,
+Redistribution and Trademark clauses below, we hereby grant you the right to
+use, copy, modify, create derivative works, publicly perform, publicly display
+and redistribute the Software for any Permitted Purpose identified below.
+
+### Permitted Purpose
+
+A Permitted Purpose is any purpose other than a Competing Use. A Competing Use
+means making the Software available to others in a commercial product or
+service that:
+
+1. substitutes for the Software;
+
+2. substitutes for any other product or service we offer using the Software
+   that exists as of the date we make the Software available; or
+
+3. offers the same or substantially similar functionality as the Software.
+
+Permitted Purposes specifically include using the Software:
+
+1. for your internal use and access;
+
+2. for non-commercial education;
+
+3. for non-commercial research; and
+
+4. in connection with professional services that you provide to a licensee
+   using the Software in accordance with these Terms and Conditions.
+
+### Patents
+
+To the extent your use for a Permitted Purpose would necessarily infringe our
+patents, the license grant above includes a license under our patents. If you
+make a claim against any party that the Software infringes or contributes to
+the infringement of any patent, then your patent license to the Software ends
+immediately.
+
+### Redistribution
+
+The Terms and Conditions apply to all copies, modifications and derivatives of
+the Software.
+
+If you redistribute any copies, modifications or derivatives of the Software,
+you must include a copy of or a link to these Terms and Conditions and not
+remove any copyright notices provided in or with the Software.
+
+### Disclaimer
+
+THE SOFTWARE IS PROVIDED "AS IS" AND WITHOUT WARRANTIES OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING WITHOUT LIMITATION WARRANTIES OF FITNESS FOR A PARTICULAR
+PURPOSE, MERCHANTABILITY, TITLE OR NON-INFRINGEMENT.
+
+IN NO EVENT WILL WE HAVE ANY LIABILITY TO YOU ARISING OUT OF OR RELATED TO THE
+SOFTWARE, INCLUDING INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES,
+EVEN IF WE HAVE BEEN INFORMED OF THEIR POSSIBILITY IN ADVANCE.
+
+### Trademarks
+
+Except for displaying the License Details and identifying us as the origin of
+the Software, you have no right under these Terms and Conditions to use our
+trademarks, trade names, service marks or product names.
+
+## Grant of Future License
+
+We hereby irrevocably grant you an additional license to use the Software under
+the MIT license that is effective on the second anniversary of the date we make
+the Software available. On or after that date, you may use the Software under
+the MIT license, in which case the following will apply:
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.