sm-resolver 0.1.0__tar.gz

sm_resolver-0.1.0/.github/workflows/ci.yml

@@ -0,0 +1,28 @@
+name: ci
+
+on:
+  push:
+    branches: [main, master]
+  pull_request:
+
+jobs:
+  ci-local:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ["3.11", "3.12"]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v5
+      - name: Pin Python
+        run: uv python pin ${{ matrix.python-version }}
+      # The same gate as `make ci-local` — green locally == green here.
+      - run: uv sync --extra dev
+      - run: uv run ruff check .
+      - run: uv run ruff format --check .
+      - run: uv run mypy sm_resolver
+      - run: uv run pytest -v
+      - name: Examples run
+        run: |
+          uv run python examples/corroborate_sources.py
+          uv run python examples/custom_layer.py

sm_resolver-0.1.0/.github/workflows/release.yml

@@ -0,0 +1,48 @@
+# Publish sm-resolver to PyPI on a version tag, via PyPI Trusted Publishing (OIDC).
+#
+# No API token anywhere: PyPI is told (once, in its web UI) to trust THIS repo +
+# THIS workflow file, and the `id-token: write` permission below lets the job
+# mint a short-lived OIDC token PyPI accepts. See PUBLISHING.md for the one-time
+# setup and the exact values to type into PyPI's "Add a publisher" form.
+#
+# Fires only when a tag like `v0.1.0` is pushed — never on normal commits.
+name: release
+
+on:
+  push:
+    tags:
+      - "v*"
+
+permissions:
+  contents: read
+
+jobs:
+  publish:
+    name: Build + publish to PyPI
+    runs-on: ubuntu-latest
+    permissions:
+      # A job-level permissions block REPLACES the workflow-level one (it does not
+      # merge), so contents:read must be restated here or actions/checkout 404s on
+      # its own repo. Both lines are required.
+      contents: read # for actions/checkout
+      id-token: write # REQUIRED for Trusted Publishing — this is what replaces the token.
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+
+      - name: Build sdist + wheel
+        run: |
+          python -m pip install --upgrade build
+          python -m build
+
+      - name: Check the built distributions
+        run: |
+          python -m pip install --upgrade twine
+          python -m twine check dist/*
+
+      - name: Publish to PyPI
+        # No `with: password:` — the action uses the OIDC token automatically.
+        uses: pypa/gh-action-pypi-publish@release/v1

sm_resolver-0.1.0/.gitignore

@@ -0,0 +1,14 @@
+__pycache__/
+*.py[cod]
+*.egg-info/
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+.venv/
+dist/
+build/
+uv.lock.tmp
+
+# Development & reconnaissance notes — design scoping, competitive research,
+# decision records. Kept local, never published.
+dev/

sm_resolver-0.1.0/CHANGELOG.md

@@ -0,0 +1,23 @@
+# Changelog
+
+All notable changes to this project are documented here. The format follows
+[Keep a Changelog](https://keepachangelog.com/) and this project adheres to
+[Semantic Versioning](https://semver.org/).
+
+## [0.1.0] — 2026-07-04
+
+Initial release — the corroboration kernel, extracted from `sm-divergence` once a
+second layer (identity) joined the first (discovery) as a consumer.
+
+### Added
+- **`View`** — the comparable-claim contract (`comparable() → named fields`).
+- **`Resolver[T]`** — the per-source adapter protocol + `Status`.
+- **`diff_views`** — the pure, generic diff (`omission` + per-field divergence),
+  with the uniform `{field, values}` finding detail.
+- **`Corroborator`** — resolve-all + diff + dedupe-emit orchestration.
+- **`Finding`** — the finding type with a stable dedup fingerprint.
+
+Zero runtime dependencies. `make ci-local` gate (ruff / format / mypy --strict /
+pytest + runnable examples) on Python 3.11 and 3.12. Full `sm-*` doc set —
+README, WHITEPAPER, SPEC, GOVERNANCE, CONTRIBUTING, PUBLISHING — plus
+`examples/` and a PyPI trusted-publishing `release.yml`.

sm_resolver-0.1.0/CONTRIBUTING.md

@@ -0,0 +1,24 @@
+# Contributing to sm-resolver
+
+Contributions are accepted under the Developer Certificate of Origin (DCO)
+sign-off model. Add `Signed-off-by: Your Name <you@example.com>` to every commit
+(`git commit -s`).
+
+## Change process
+
+1. Spec-affecting changes open a PR updating the **spec (`SPEC.md`), the tests,
+   and the code together**. The `tests/` suite is the authoritative behavioural
+   specification of the diff.
+2. The gate is `make ci-local` (uv: `ruff` → `ruff format` → `mypy --strict` →
+   `pytest`). CI runs the same on Python 3.11 and 3.12. Push only when green.
+
+## House rules
+
+- **A timeout is not a claim.** An unreachable or erroring source MUST be
+  excluded from the diff, never counted as an omission. A change here needs an
+  RFC-style PR to `SPEC.md` first.
+- **The diff stays pure and generic.** `diff_views` is deterministic, does no
+  I/O, never raises, and never learns its layer. All I/O lives in resolvers.
+- **Zero runtime dependencies.** The kernel is stdlib-only; keep it that way.
+- **No expansion of the classification (SPEC §2), the view contract (SPEC §3), or
+  the diff (SPEC §4) without an RFC-style PR to `SPEC.md` first.**

sm_resolver-0.1.0/GOVERNANCE.md

@@ -0,0 +1,22 @@
+# Governance
+
+## Scope
+
+| In scope | Out of scope |
+| --- | --- |
+| the claim classification (`present`/`absent`/`error`), the view contract (`comparable()`), the pure diff (`omission` + per-field), and the `Corroborator` orchestration | any specific source format or transport (a consumer's resolver owns that); the view type's fields (the consumer defines them); signing / verification (a consumer's resolver applies it before returning a view); a transparency log; and remediation policy on a finding |
+
+The kernel owns one thing — answering *"do these sources disagree about this
+subject, and how?"* — for any view type and any layer. Anything outside the table
+belongs to a consumer (e.g. `sm-divergence`) or the caller.
+
+## Versioning
+
+Semantic Versioning 2.0.0. The claim classification (SPEC §2), the view contract
+(SPEC §3), and the diff (SPEC §4) are frozen within a major; a change requires an
+RFC-style PR to `SPEC.md` before code.
+
+## Conformance
+
+An implementation is conforming iff it reproduces the finding set in SPEC §6. The
+diff is pure and deterministic by construction, so conformance is mechanical.

sm_resolver-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 stellarminds.ai
+
+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.

sm_resolver-0.1.0/Makefile

@@ -0,0 +1,10 @@
+.PHONY: ci-local
+# One-command pre-push gate — the same steps CI runs, hard-failing on first red.
+ci-local:
+	uv sync --extra dev
+	uv run ruff check .
+	uv run ruff format --check .
+	uv run mypy sm_resolver
+	uv run pytest -v
+	uv run python examples/corroborate_sources.py
+	uv run python examples/custom_layer.py

sm_resolver-0.1.0/PKG-INFO

@@ -0,0 +1,111 @@
+Metadata-Version: 2.4
+Name: sm-resolver
+Version: 0.1.0
+Summary: The source-agnostic corroboration kernel — Resolver[T], the View contract, a pure diff, and the Corroborator. Zero runtime dependencies.
+Project-URL: Homepage, https://github.com/Sharathvc23/sm-resolver
+Project-URL: Spec, https://github.com/Sharathvc23/sm-resolver/blob/main/SPEC.md
+Project-URL: Whitepaper, https://github.com/Sharathvc23/sm-resolver/blob/main/WHITEPAPER.md
+Author: Sharath (Stellarminds)
+License: MIT
+License-File: LICENSE
+Keywords: accountability,ai-agents,corroboration,divergence,nanda,resolver
+Requires-Python: >=3.11
+Provides-Extra: dev
+Requires-Dist: mypy>=1.10; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.23; extra == 'dev'
+Requires-Dist: pytest>=8; extra == 'dev'
+Requires-Dist: ruff>=0.6; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# sm-resolver — the corroboration kernel
+
+**A tiny, dependency-free kernel for detecting when independent sources disagree
+about the same subject.** Point it at two or more sources, ask them the same
+question, and it reports any disagreement. It is the machinery under
+cross-registry / cross-method divergence detection, factored out so any layer can
+reuse it.
+
+Four pieces, and only the resolvers know a wire format:
+
+- **`View`** — the contract a claim implements: `comparable() → {field: value}`.
+  Those fields are what gets compared; a `None` value never participates.
+- **`Resolver[T]`** — a per-source adapter: a canonical id → `(Status, View)`.
+  It hides one source's format (an HTTP GET, a DID resolve, a DNS lookup) and
+  MUST NOT raise — an unreachable source is `error` (no claim), never a false
+  `absent`.
+- **`diff_views`** — the pure diff: per-source claims → `Finding` list. It emits
+  `omission` (present on one source, positively absent on another) and one
+  finding per view field whose values disagree. It never learns its layer.
+- **`Corroborator`** — resolve every source, diff, and emit new findings once
+  (deduped). Fewer than two sources → no-op.
+
+## Install
+
+```bash
+pip install sm-resolver        # zero runtime dependencies
+```
+
+## Use
+
+Supply a view (its fields are what you compare) and a thin resolver per source:
+
+```python
+import asyncio
+from collections.abc import Mapping
+from dataclasses import dataclass
+from sm_resolver import Corroborator, Status
+
+@dataclass(frozen=True)
+class RecordView:                       # your layer's view
+    endpoint: str | None = None
+    def comparable(self) -> Mapping[str, str | None]:
+        return {"endpoint": self.endpoint}
+
+class MyResolver:                       # your thin per-source adapter
+    def __init__(self, label): self.label = label
+    async def resolve(self, agent_id) -> tuple[Status, RecordView | None]:
+        ...                             # query this source; normalize to RecordView
+
+findings = asyncio.run(
+    Corroborator([MyResolver("a"), MyResolver("b")]).check(["agent-1"])
+)
+for f in findings:
+    print(f.kind, f.agent_id, f.detail)
+    # endpoint agent-1 {'field': 'endpoint', 'values': {'a': 'https://real', 'b': 'https://evil'}}
+```
+
+Long-running? Pass `on_finding=` — it fires once per distinct finding across the
+corroborator's lifetime.
+
+## Who uses it
+
+[`sm-divergence`](https://github.com/Sharathvc23/sm-divergence) builds the
+reference layers on this kernel: a **discovery** layer (registries — NEST, the
+NANDA Index) and an **identity** layer (DID methods — `did:key`, `did:web`,
+Universal Resolver), each supplying its own view and thin resolvers. Capability
+and evidence layers are the same shape.
+
+## Design rules
+
+- **A timeout is not a claim.** An unreachable or erroring source is excluded,
+  never counted as an omission.
+- **Only present, comparable values disagree.** A `None` field contributes
+  nothing — an unverifiable value is not a disagreement.
+- **The diff stays pure and generic** — deterministic, no I/O, never raises,
+  never learns its layer. All I/O lives in the resolvers.
+
+## Develop
+
+```bash
+make ci-local   # uv: sync → ruff → format → mypy --strict → pytest
+```
+
+## License
+
+[MIT](LICENSE)
+
+---
+
+*First published: 2026-07-04 | Last modified: 2026-07-04*
+
+*Personal research contributions aligned with [Project NANDA](https://projectnanda.org) standards. [Stellarminds.ai](https://stellarminds.ai)*

sm_resolver-0.1.0/PUBLISHING.md

@@ -0,0 +1,42 @@
+# Publishing sm-resolver to PyPI
+
+`sm-resolver` publishes via **PyPI Trusted Publishing** — no API tokens. You tell
+PyPI once that this repo's `release.yml` workflow may publish; after that, pushing
+a version tag builds and uploads automatically.
+
+## One-time setup (≈5 minutes — this is the part only you can do)
+
+1. Sign in to PyPI (the same account that publishes the rest of the `sm-*` family).
+2. Go to **https://pypi.org/manage/account/publishing/** → "Add a pending
+   publisher" (use *pending*, because the `sm-resolver` project doesn't exist on
+   PyPI yet — the first publish creates it).
+3. Fill the form with **exactly** these values:
+
+   | Field | Value |
+   |-------|-------|
+   | PyPI Project Name | `sm-resolver` |
+   | Owner | `Sharathvc23` |
+   | Repository name | `sm-resolver` |
+   | **Workflow name** | `release.yml`  ← just the filename |
+   | Environment name | *(leave blank)* |
+
+That's it. No secret is created or stored anywhere.
+
+## Releasing (every time, after setup)
+
+```bash
+# bump `version` in pyproject.toml + update CHANGELOG, commit, then:
+git tag v0.1.0
+git push origin v0.1.0
+```
+
+The `release` workflow builds the sdist + wheel, runs `twine check`, and uploads
+to PyPI over OIDC. Watch it under the repo's **Actions** tab. Within a minute,
+`pip install sm-resolver` works for everyone.
+
+## Notes
+
+- The tag (`v0.1.0`) and `version` in `pyproject.toml` must match.
+- Dry run anytime, no upload: `python -m build && python -m twine check dist/*`.
+- Making this public also unblocks `sm-divergence`'s CI, which depends on this
+  package (a private dependency otherwise needs a PAT to clone in Actions).

sm_resolver-0.1.0/README.md

@@ -0,0 +1,92 @@
+# sm-resolver — the corroboration kernel
+
+**A tiny, dependency-free kernel for detecting when independent sources disagree
+about the same subject.** Point it at two or more sources, ask them the same
+question, and it reports any disagreement. It is the machinery under
+cross-registry / cross-method divergence detection, factored out so any layer can
+reuse it.
+
+Four pieces, and only the resolvers know a wire format:
+
+- **`View`** — the contract a claim implements: `comparable() → {field: value}`.
+  Those fields are what gets compared; a `None` value never participates.
+- **`Resolver[T]`** — a per-source adapter: a canonical id → `(Status, View)`.
+  It hides one source's format (an HTTP GET, a DID resolve, a DNS lookup) and
+  MUST NOT raise — an unreachable source is `error` (no claim), never a false
+  `absent`.
+- **`diff_views`** — the pure diff: per-source claims → `Finding` list. It emits
+  `omission` (present on one source, positively absent on another) and one
+  finding per view field whose values disagree. It never learns its layer.
+- **`Corroborator`** — resolve every source, diff, and emit new findings once
+  (deduped). Fewer than two sources → no-op.
+
+## Install
+
+```bash
+pip install sm-resolver        # zero runtime dependencies
+```
+
+## Use
+
+Supply a view (its fields are what you compare) and a thin resolver per source:
+
+```python
+import asyncio
+from collections.abc import Mapping
+from dataclasses import dataclass
+from sm_resolver import Corroborator, Status
+
+@dataclass(frozen=True)
+class RecordView:                       # your layer's view
+    endpoint: str | None = None
+    def comparable(self) -> Mapping[str, str | None]:
+        return {"endpoint": self.endpoint}
+
+class MyResolver:                       # your thin per-source adapter
+    def __init__(self, label): self.label = label
+    async def resolve(self, agent_id) -> tuple[Status, RecordView | None]:
+        ...                             # query this source; normalize to RecordView
+
+findings = asyncio.run(
+    Corroborator([MyResolver("a"), MyResolver("b")]).check(["agent-1"])
+)
+for f in findings:
+    print(f.kind, f.agent_id, f.detail)
+    # endpoint agent-1 {'field': 'endpoint', 'values': {'a': 'https://real', 'b': 'https://evil'}}
+```
+
+Long-running? Pass `on_finding=` — it fires once per distinct finding across the
+corroborator's lifetime.
+
+## Who uses it
+
+[`sm-divergence`](https://github.com/Sharathvc23/sm-divergence) builds the
+reference layers on this kernel: a **discovery** layer (registries — NEST, the
+NANDA Index) and an **identity** layer (DID methods — `did:key`, `did:web`,
+Universal Resolver), each supplying its own view and thin resolvers. Capability
+and evidence layers are the same shape.
+
+## Design rules
+
+- **A timeout is not a claim.** An unreachable or erroring source is excluded,
+  never counted as an omission.
+- **Only present, comparable values disagree.** A `None` field contributes
+  nothing — an unverifiable value is not a disagreement.
+- **The diff stays pure and generic** — deterministic, no I/O, never raises,
+  never learns its layer. All I/O lives in the resolvers.
+
+## Develop
+
+```bash
+make ci-local   # uv: sync → ruff → format → mypy --strict → pytest
+```
+
+## License
+
+[MIT](LICENSE)
+
+---
+
+*First published: 2026-07-04 | Last modified: 2026-07-04*
+
+*Personal research contributions aligned with [Project NANDA](https://projectnanda.org) standards. [Stellarminds.ai](https://stellarminds.ai)*

sm_resolver-0.1.0/SPEC.md

@@ -0,0 +1,66 @@
+# Corroboration Kernel — Procedure
+
+**Spec version:** `resolver/0.1-draft`
+**Status:** DRAFT / Working Draft
+**Last edited:** 2026-07-04
+
+The keywords MUST, MUST NOT, SHOULD, SHOULD NOT, MAY are to be interpreted as in RFC 2119.
+
+---
+
+## 1. Introduction
+
+Given several **sources** that each answer "what do you have for subject *X*?",
+the kernel classifies each source's claim, reduces a present claim to a
+comparable **view**, and diffs the views into findings. It is source-, format-,
+and layer-agnostic; a consumer supplies a view type and a resolver per source.
+
+## 2. Claim classification
+
+For a source *S* and subject *A*, a resolver MUST resolve exactly one of:
+
+- **`present`** — *S* served a claim, reduced to a view (§3).
+- **`absent`** — *S* positively asserts *A* is unknown.
+- **`error`** — any other outcome (unreachable, timeout, unparseable, or a claim
+  the resolver cannot map to a view).
+
+An `error` claim MUST be excluded from the diff entirely. It is NOT `absent`: **a
+source that failed to answer has asserted nothing, and MUST NOT be treated as
+claiming the subject is absent.** A resolver MUST NOT raise; a failure is `error`.
+
+## 3. The view contract
+
+A `present` claim MUST be reduced to a **view**: an object exposing
+`comparable() → Mapping[field_name, str | None]`. The keys are the fields that
+participate in the diff; a value of `None` never participates (an unverifiable or
+missing field is not a disagreement). The view type is the consumer's choice.
+
+## 4. The diff
+
+Input is `views[source][subject]`: a view (present), `null` (absent), or *absent
+from the mapping* (the `error` case — no claim). Per subject:
+
+- **`omission`** — emit iff present on ≥1 source AND absent on ≥1 other (both
+  positive claims). Detail: `{present_on, missing_from}` (sorted source lists).
+- **field divergence** — for each field name in any present view's
+  `comparable()`, collect the non-`None` values keyed by source; emit a finding
+  of `kind = <field name>` iff more than one distinct value appears. Detail:
+  `{"field": <name>, "values": {source: value}}`.
+
+The diff MUST be pure: deterministic, no I/O, no raising. A subject MAY produce
+multiple findings.
+
+## 5. Corroborator
+
+A `Corroborator` takes two or more resolvers, resolves each subject against each,
+builds the `views` mapping (excluding `error` claims), and applies §4. Fewer than
+two sources → no-op. It SHOULD deduplicate emitted findings by a stable
+fingerprint over `{kind, agent_id, detail}`.
+
+## 6. Conformance
+
+A conforming implementation MUST reproduce, for a fixed set of per-source claim
+inputs, the §4 finding set: agreement → none; present + absent → `omission`;
+distinct field values → a finding of that field's kind; single/identical value or
+one-value-beside-`None` → none; `error`/unreachable → excluded (no `omission`).
+The diff is pure and deterministic, so conformance is mechanical.

sm_resolver-0.1.0/WHITEPAPER.md

@@ -0,0 +1,118 @@
+# sm-resolver: A Corroboration Kernel for the Internet of AI Agents
+
+*Personal research contribution by [Stellarminds.ai](https://stellarminds.ai), aligned with [Project NANDA](https://projectnanda.org) standards.*
+
+---
+
+## Abstract
+
+Accountability for a federated system where agents reach each other through
+middlemen — registries, name services, DID methods, catalogs — reduces to one
+question asked over and over: *do independent sources agree about the same
+subject, and if not, how do they differ?* This paper describes the minimal,
+source-agnostic machinery that answers it: a per-source **resolver** that
+normalizes any format to one comparable **view**, and a pure **diff** that turns
+the views from all sources into findings. `sm-resolver` is that machinery and
+nothing else — a dependency-free kernel other packages build layers on.
+
+## 1. Problem
+
+A middleman can lie: it can tamper with what it serves, omit a subject it holds,
+or equivocate between clients. Signing an artifact defeats tampering, but no
+signature proves what a source *withheld* or whether it showed everyone the same
+thing. The robust defense is corroboration — ask two or more sources and treat
+disagreement as a signal — and it recurs at every layer: a registry about an
+agent's endpoint, a DID method about its key, a catalog about its capabilities.
+The comparison logic is identical each time; only the wire format differs. Left
+un-factored, every layer reimplements the same diff and the same "a timeout is
+not an absence" subtleties, and drifts.
+
+## 2. The corroboration primitive
+
+The operation factors into three pieces, and only the first knows a format:
+
+- **Resolve** — a per-source *resolver* performs that source's query, applies its
+  native verification, and returns a *view*. It is the only format-aware piece;
+  a thin adapter lives here.
+- **View** — the comparable reduction of a claim to named string fields
+  (`comparable() → {field: value}`). A `None` value never participates.
+- **Diff** — a pure function over the views from all sources. It emits `omission`
+  (present on one, positively absent on another) and one finding per view field
+  whose values disagree. It never learns what layer it serves.
+
+Because the diff operates on normalized views, it is untouched by format
+heterogeneity — the same code compares a registry claim and a DID-document claim
+once each is a view. A `Corroborator` wires it together: resolve every source,
+diff, emit new findings once.
+
+## 3. Why it is a separate package
+
+The kernel is small (three types and one pure function) but it is the part every
+accountability layer shares, so it earns its own package the moment a second
+layer consumes it. Extracting it keeps each layer a *thin adapter* — a view type
+and per-source resolvers — with no generic machinery of its own, and lets a layer
+depend on the kernel without dragging any sibling's wire code along. The kernel
+carries **zero runtime dependencies**, so adopting it commits a consumer to
+nothing but the standard library.
+
+## 4. Design axioms
+
+Consequences of the threat model, not preferences.
+
+1. **Corroborate, don't trust.** One artifact proves its own contents, not that
+   the source served it honestly or to everyone. The minimum unit of
+   accountability is two independent sources; with one, the kernel is a no-op
+   rather than false assurance.
+2. **A timeout is not a claim.** An unreachable source has asserted nothing and
+   is excluded — never counted as an omission — so a transient fault cannot
+   manufacture a false finding.
+3. **Only present, comparable values disagree.** A `None` field contributes
+   nothing; an unverifiable value is not a disagreement and cannot be laundered
+   into one that discredits an honest source.
+4. **Detect; do not remediate.** The kernel reports *that* sources disagree and
+   *how*. What to do about it is caller policy.
+
+## 5. Composition
+
+`sm-resolver` is the base; layers supply a view and resolvers:
+
+```
+                         sm-resolver  (View · Resolver[T] · diff · Corroborator)
+                                    ▲                ▲               ▲
+                        discovery layer      identity layer     capability / evidence
+                        RecordView +         DidView +           (a view + resolvers)
+                        registry resolvers   DID-method resolvers
+```
+
+[`sm-divergence`](https://github.com/Sharathvc23/sm-divergence) is the reference
+consumer: a discovery layer (registries — NEST, the NANDA Index) and an identity
+layer (DID methods — `did:key`, `did:web`, a Universal Resolver), each a thin set
+of resolvers over this kernel.
+
+## 6. NANDA alignment
+
+Project NANDA's discovery is multi-source by design — a lean Index delegating to
+a quilt of registries. Corroboration is only *possible* because of that
+decentralization: the redundancy built for resilience doubles as an integrity
+check. `sm-resolver` is the mechanism that turns that latent property into an
+active one, underpinning **accountable discovery** across the DNS and CA pillars.
+
+## 7. Future work
+
+- A quorum reducer over findings (*k*-of-*n* agreement) for more than two sources.
+- Durable per-source divergence history (source reputation).
+- A normative wire schema for a shareable `Finding` (cross-tool interchange).
+
+## 8. Related packages
+
+| Package | Role |
+| --- | --- |
+| [`sm-divergence`](https://github.com/Sharathvc23/sm-divergence) | The reference discovery + identity layers built on this kernel. |
+| [`sm-bridge`](https://github.com/Sharathvc23/sm-bridge) | NANDA-compatible registry endpoints — a source a resolver corroborates across. |
+| [`sm-conformance`](https://github.com/Sharathvc23/sm-conformance) | The shared Ed25519 / JCS signing convention a resolver's verification uses. |
+
+---
+
+## License
+
+[MIT](LICENSE).