fjp-conformance 0.1.0__tar.gz

fjp_conformance-0.1.0/LICENSE

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

fjp_conformance-0.1.0/NOTICE

@@ -0,0 +1,16 @@
+Flow Judgment Protocol Conformance (FJP-CONF)
+Copyright 2026 Flow Information Systems
+
+This product was created and is maintained by Flow Information Systems
+(https://flowinfo.co).
+
+Flow Judgment Protocol™, FJP™, FJP-CONF™, Judgment-Grounded Agent™,
+Judgment-Grounded™, Flow™, and Flow Information Systems™, together with the
+tagline "DNS resolves location. Flow resolves importance."™, are trademarks of
+Flow Information Systems. See TRADEMARKS.md for the trademark usage policy.
+
+The Apache License, Version 2.0 (LICENSE) governs use of the source code in this
+repository. It does not grant any right to use the trademarks listed above.
+
+This NOTICE file must be preserved in redistributions of this work, per Section 4
+of the Apache License, Version 2.0.

fjp_conformance-0.1.0/PKG-INFO

@@ -0,0 +1,117 @@
+Metadata-Version: 2.4
+Name: fjp-conformance
+Version: 0.1.0
+Summary: FJP-CONF v0.1 — behavioral conformance suite for Judgment-Grounded Agents.
+License: Apache-2.0
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+License-File: NOTICE
+Provides-Extra: dev
+Requires-Dist: pytest>=7; extra == "dev"
+Dynamic: license-file
+
+# FJP-CONF — Flow Judgment Protocol Conformance
+
+**Flow Judgment Protocol™ (FJP)** is the judgment layer for AI agents and
+enterprise decision systems. It determines what changed, whether it matters, what
+matters most, and what should happen next.
+
+**FJP-CONF** is the public, vendor-neutral conformance standard for FJP. It defines
+what it means for an agent to make **accountable** decisions — decisions that can
+be traced, challenged, and audited — and ships a runnable test suite so any
+developer can verify their own agent.
+
+- **Specification:** [`spec/v0.1.md`](./spec/v0.1.md) · field reference: [`spec/schema.md`](./spec/schema.md)
+- **Canonical URL:** https://fjp.flowinfo.co/conformance/v0.1
+- **Status:** v0.1.0 — public draft
+
+FJP-CONF tests an agent's **observable output**, not its internal method. Two
+agents may reach opposite conclusions and both conform. Conformance asserts that a
+decision is *accountable* — not that it is *correct*.
+
+## The idea in one paragraph
+
+Retrieval-grade systems answer *what is true*. They do not answer *was this worth
+acting on, and how would we know if it wasn't*. When an agent acts, three questions
+must be answerable afterward: what did it act on, why did it judge that worth acting
+on, and what would have made that judgment wrong. FJP-CONF defines the minimum
+externalized structure — the **Judgment-Grounded Record** — that makes those
+questions answerable, independent of how the agent decides.
+
+## The Judgment-Grounded Record
+
+For every action it recommends or takes, a conforming agent emits a record with
+four components:
+
+| Component   | Answers             |
+|-------------|---------------------|
+| `signal`    | what changed        |
+| `judgment`  | why it matters      |
+| `action`    | what should happen  |
+| `falsifier` | what would make it wrong |
+
+## Conformance levels
+
+| Level | Name         | Adds                                                        |
+|-------|--------------|-------------------------------------------------------------|
+| L0    | Structural   | A well-formed record with all four components.              |
+| L1    | Grounded     | Attributable signal; the action traces back to it.          |
+| L2    | Falsifiable  | A concrete, checkable condition that would reverse the call. |
+| L3    | Accountable  | Records are retained and the falsifier can be re-evaluated.  |
+
+## Quickstart
+
+Requires Python 3.11+. No third-party dependencies.
+
+```bash
+# validate a record at Level 2
+python -m conformance.runner examples/passing_agent.json --level 2
+
+# a non-conforming record
+python -m conformance.runner examples/failing_agent.json --level 2
+```
+
+Exit codes: `0` conforms · `1` does not conform · `2` invalid input.
+
+Programmatic use:
+
+```python
+from conformance import evaluate, conforms
+
+results = evaluate(record, level=2)
+print(conforms(results))
+```
+
+Level 3 requires your agent to implement a small adapter
+(`get_record`, `evaluate_falsifier`); see [`conformance/adapter.py`](./conformance/adapter.py)
+and [`examples/passing_agent_l3.py`](./examples/passing_agent_l3.py).
+
+Run the tests:
+
+```bash
+python -m pytest -q
+```
+
+## Claiming conformance
+
+A conformance claim names a level and version and is reproducible by running this
+suite against your agent's output:
+
+> "Conforms to FJP-CONF v0.1, Level 2."
+
+Authoritative verification and any official FJP-CONF certification are administered
+by Flow Information Systems. This open suite lets anyone self-check; see
+[`TRADEMARKS.md`](./TRADEMARKS.md) for what you may and may not call your
+implementation.
+
+## License and trademarks
+
+Source code is licensed under the Apache License, Version 2.0 — see
+[`LICENSE`](./LICENSE). The code license does **not** grant rights in the
+trademarks.
+
+**Flow Judgment Protocol™, FJP™, FJP-CONF™, Judgment-Grounded Agent™,** and
+**"DNS resolves location. Flow resolves importance."™** are trademarks of
+**Flow Information Systems** (https://flowinfo.co). See [`NOTICE`](./NOTICE) and
+[`TRADEMARKS.md`](./TRADEMARKS.md).

fjp_conformance-0.1.0/README.md

@@ -0,0 +1,104 @@
+# FJP-CONF — Flow Judgment Protocol Conformance
+
+**Flow Judgment Protocol™ (FJP)** is the judgment layer for AI agents and
+enterprise decision systems. It determines what changed, whether it matters, what
+matters most, and what should happen next.
+
+**FJP-CONF** is the public, vendor-neutral conformance standard for FJP. It defines
+what it means for an agent to make **accountable** decisions — decisions that can
+be traced, challenged, and audited — and ships a runnable test suite so any
+developer can verify their own agent.
+
+- **Specification:** [`spec/v0.1.md`](./spec/v0.1.md) · field reference: [`spec/schema.md`](./spec/schema.md)
+- **Canonical URL:** https://fjp.flowinfo.co/conformance/v0.1
+- **Status:** v0.1.0 — public draft
+
+FJP-CONF tests an agent's **observable output**, not its internal method. Two
+agents may reach opposite conclusions and both conform. Conformance asserts that a
+decision is *accountable* — not that it is *correct*.
+
+## The idea in one paragraph
+
+Retrieval-grade systems answer *what is true*. They do not answer *was this worth
+acting on, and how would we know if it wasn't*. When an agent acts, three questions
+must be answerable afterward: what did it act on, why did it judge that worth acting
+on, and what would have made that judgment wrong. FJP-CONF defines the minimum
+externalized structure — the **Judgment-Grounded Record** — that makes those
+questions answerable, independent of how the agent decides.
+
+## The Judgment-Grounded Record
+
+For every action it recommends or takes, a conforming agent emits a record with
+four components:
+
+| Component   | Answers             |
+|-------------|---------------------|
+| `signal`    | what changed        |
+| `judgment`  | why it matters      |
+| `action`    | what should happen  |
+| `falsifier` | what would make it wrong |
+
+## Conformance levels
+
+| Level | Name         | Adds                                                        |
+|-------|--------------|-------------------------------------------------------------|
+| L0    | Structural   | A well-formed record with all four components.              |
+| L1    | Grounded     | Attributable signal; the action traces back to it.          |
+| L2    | Falsifiable  | A concrete, checkable condition that would reverse the call. |
+| L3    | Accountable  | Records are retained and the falsifier can be re-evaluated.  |
+
+## Quickstart
+
+Requires Python 3.11+. No third-party dependencies.
+
+```bash
+# validate a record at Level 2
+python -m conformance.runner examples/passing_agent.json --level 2
+
+# a non-conforming record
+python -m conformance.runner examples/failing_agent.json --level 2
+```
+
+Exit codes: `0` conforms · `1` does not conform · `2` invalid input.
+
+Programmatic use:
+
+```python
+from conformance import evaluate, conforms
+
+results = evaluate(record, level=2)
+print(conforms(results))
+```
+
+Level 3 requires your agent to implement a small adapter
+(`get_record`, `evaluate_falsifier`); see [`conformance/adapter.py`](./conformance/adapter.py)
+and [`examples/passing_agent_l3.py`](./examples/passing_agent_l3.py).
+
+Run the tests:
+
+```bash
+python -m pytest -q
+```
+
+## Claiming conformance
+
+A conformance claim names a level and version and is reproducible by running this
+suite against your agent's output:
+
+> "Conforms to FJP-CONF v0.1, Level 2."
+
+Authoritative verification and any official FJP-CONF certification are administered
+by Flow Information Systems. This open suite lets anyone self-check; see
+[`TRADEMARKS.md`](./TRADEMARKS.md) for what you may and may not call your
+implementation.
+
+## License and trademarks
+
+Source code is licensed under the Apache License, Version 2.0 — see
+[`LICENSE`](./LICENSE). The code license does **not** grant rights in the
+trademarks.
+
+**Flow Judgment Protocol™, FJP™, FJP-CONF™, Judgment-Grounded Agent™,** and
+**"DNS resolves location. Flow resolves importance."™** are trademarks of
+**Flow Information Systems** (https://flowinfo.co). See [`NOTICE`](./NOTICE) and
+[`TRADEMARKS.md`](./TRADEMARKS.md).

fjp_conformance-0.1.0/conformance/__init__.py

@@ -0,0 +1,25 @@
+"""FJP-CONF v0.1 — Judgment-Grounded Agent conformance suite."""
+
+from .schema import SPEC_VERSION
+from .checks import (
+    Result,
+    check_l0,
+    check_l1,
+    check_l2,
+    check_l3,
+    evaluate,
+    conforms,
+)
+from .adapter import JudgmentGroundedAgent
+
+__all__ = [
+    "SPEC_VERSION",
+    "Result",
+    "check_l0",
+    "check_l1",
+    "check_l2",
+    "check_l3",
+    "evaluate",
+    "conforms",
+    "JudgmentGroundedAgent",
+]

fjp_conformance-0.1.0/conformance/adapter.py

@@ -0,0 +1,30 @@
+"""FJP-CONF v0.1 — L3 agent adapter interface.
+
+An agent claiming Level 3 (Accountable) implements this protocol so the
+conformance suite can retrieve a past record and re-evaluate its falsifier.
+The suite tests the *interface behavior*, never the agent's internal method.
+"""
+
+from __future__ import annotations
+
+from typing import Protocol, runtime_checkable
+
+
+@runtime_checkable
+class JudgmentGroundedAgent(Protocol):
+    """Minimal interface an L3-conformant agent must expose."""
+
+    def get_record(self, record_id: str) -> dict:
+        """Return the stored Judgment-Grounded Record for `record_id`.
+
+        MUST return a dict whose `record_id` equals the argument and which is a
+        valid (L0) JGR. MAY raise if the id is unknown.
+        """
+        ...
+
+    def evaluate_falsifier(self, record_id: str) -> str:
+        """Re-evaluate the record's falsifier against the current world.
+
+        MUST return one of: "open", "triggered", "expired".
+        """
+        ...

fjp_conformance-0.1.0/conformance/checks.py

@@ -0,0 +1,209 @@
+"""FJP-CONF v0.1 — conformance checks.
+
+Each check function returns a list of Result tuples. A record conforms to a level
+if every check at that level (and below) passes. Stdlib only.
+"""
+
+from __future__ import annotations
+
+import datetime as _dt
+from typing import List, NamedTuple
+
+from . import schema
+
+
+class Result(NamedTuple):
+    check_id: str
+    level: int
+    passed: bool
+    detail: str
+
+
+# ----------------------------------------------------------------------------- #
+# helpers
+# ----------------------------------------------------------------------------- #
+
+def _is_nonempty_str(v) -> bool:
+    return isinstance(v, str) and v.strip() != ""
+
+
+def _valid_iso8601(v) -> bool:
+    if not isinstance(v, str) or not v.strip():
+        return False
+    s = v.strip().replace("Z", "+00:00")
+    try:
+        _dt.datetime.fromisoformat(s)
+        return True
+    except ValueError:
+        return False
+
+
+def _obj(record: dict, key: str) -> dict:
+    v = record.get(key)
+    return v if isinstance(v, dict) else {}
+
+
+# ----------------------------------------------------------------------------- #
+# L0 — structural
+# ----------------------------------------------------------------------------- #
+
+def check_l0(record: dict) -> List[Result]:
+    r: List[Result] = []
+    add = lambda cid, ok, msg: r.append(Result(cid, 0, ok, msg))
+
+    # Defensive: a record must be a JSON object. Guard here so every caller
+    # (CLI, tests, and any future hosted verifier) fails cleanly instead of
+    # crashing on adversarial or malformed input.
+    if not isinstance(record, dict):
+        add("L0.record.is_object", False,
+            f"record must be a JSON object (got {type(record).__name__})")
+        return r
+
+    add("L0.record_id", _is_nonempty_str(record.get("record_id")),
+        "record_id must be a non-empty string")
+    add("L0.timestamp", _valid_iso8601(record.get("timestamp")),
+        "timestamp must be valid ISO 8601")
+
+    for comp in ("signal", "judgment", "action", "falsifier"):
+        add(f"L0.{comp}.present", isinstance(record.get(comp), dict),
+            f"{comp} must be present and an object")
+
+    sig, jud, act, fal = (_obj(record, k) for k in
+                          ("signal", "judgment", "action", "falsifier"))
+
+    add("L0.signal.description", _is_nonempty_str(sig.get("description")),
+        "signal.description must be a non-empty string")
+    add("L0.signal.observed_at", _valid_iso8601(sig.get("observed_at")),
+        "signal.observed_at must be valid ISO 8601")
+
+    add("L0.judgment.assessment", _is_nonempty_str(jud.get("assessment")),
+        "judgment.assessment must be a non-empty string")
+    conf = jud.get("confidence")
+    add("L0.judgment.confidence",
+        isinstance(conf, (int, float)) and not isinstance(conf, bool)
+        and 0.0 <= float(conf) <= 1.0,
+        "judgment.confidence must be a number in [0, 1]")
+
+    add("L0.action.directive", _is_nonempty_str(act.get("directive")),
+        "action.directive must be a non-empty string")
+
+    add("L0.falsifier.condition", _is_nonempty_str(fal.get("condition")),
+        "falsifier.condition must be a non-empty string")
+    return r
+
+
+# ----------------------------------------------------------------------------- #
+# L1 — grounded
+# ----------------------------------------------------------------------------- #
+
+def check_l1(record: dict) -> List[Result]:
+    r: List[Result] = []
+    add = lambda cid, ok, msg: r.append(Result(cid, 1, ok, msg))
+
+    sig, jud, act = (_obj(record, k) for k in ("signal", "judgment", "action"))
+
+    sources = sig.get("sources")
+    add("L1.signal.sources",
+        isinstance(sources, list) and any(_is_nonempty_str(s) for s in sources),
+        "signal.sources must be a non-empty list of identifiers")
+
+    sig_id = schema.canonical_signal_id(sig)
+    add("L1.judgment.signal_ref",
+        _is_nonempty_str(jud.get("signal_ref")) and jud.get("signal_ref") == sig_id,
+        "judgment.signal_ref must match the signal's canonical identity")
+
+    jud_id = schema.canonical_judgment_id(jud)
+    add("L1.action.judgment_ref",
+        _is_nonempty_str(act.get("judgment_ref")) and act.get("judgment_ref") == jud_id,
+        "action.judgment_ref must match the judgment's canonical identity")
+    return r
+
+
+# ----------------------------------------------------------------------------- #
+# L2 — falsifiable
+# ----------------------------------------------------------------------------- #
+
+def _is_vacuous(condition: str) -> bool:
+    c = condition.lower()
+    if any(bad in c for bad in schema.VACUITY_BLOCKLIST):
+        return True
+    has_marker = any(m in c for m in schema.CONCRETENESS_MARKERS)
+    has_digit = any(ch.isdigit() for ch in c)
+    # Concrete if it has a comparison/event marker OR a number.
+    return not (has_marker or has_digit)
+
+
+def check_l2(record: dict) -> List[Result]:
+    r: List[Result] = []
+    add = lambda cid, ok, msg: r.append(Result(cid, 2, ok, msg))
+
+    fal = _obj(record, "falsifier")
+    cond = fal.get("condition", "")
+
+    add("L2.falsifier.checkable", fal.get("checkable") is True,
+        "falsifier.checkable must be exactly true")
+    add("L2.falsifier.status", fal.get("status") in schema.VALID_STATUSES,
+        f"falsifier.status must be one of {schema.VALID_STATUSES}")
+    add("L2.falsifier.concrete",
+        _is_nonempty_str(cond) and not _is_vacuous(cond),
+        "falsifier.condition must be concrete (references a threshold, quantity, "
+        "dated bound, or event) and not a vacuous catch-all")
+    return r
+
+
+# ----------------------------------------------------------------------------- #
+# L3 — accountable (requires an adapter; see adapter.py)
+# ----------------------------------------------------------------------------- #
+
+def check_l3(adapter, record_id: str) -> List[Result]:
+    """L3 validates the agent can retrieve a record and re-evaluate its falsifier.
+
+    `adapter` must implement get_record(record_id) -> dict and
+    evaluate_falsifier(record_id) -> str. See conformance/adapter.py.
+    """
+    r: List[Result] = []
+    add = lambda cid, ok, msg: r.append(Result(cid, 3, ok, msg))
+
+    try:
+        rec = adapter.get_record(record_id)
+    except Exception as e:  # noqa: BLE001 - conformance must not crash on impl errors
+        add("L3.get_record", False, f"get_record raised: {e!r}")
+        return r
+
+    add("L3.get_record.returns_record",
+        isinstance(rec, dict) and rec.get("record_id") == record_id,
+        "get_record must return the JGR with the requested record_id")
+
+    # The retrieved record must itself still be structurally valid.
+    l0_ok = all(res.passed for res in check_l0(rec)) if isinstance(rec, dict) else False
+    add("L3.get_record.valid_jgr", l0_ok,
+        "retrieved record must still be a valid (L0) JGR")
+
+    try:
+        status = adapter.evaluate_falsifier(record_id)
+        add("L3.evaluate_falsifier", status in schema.VALID_STATUSES,
+            f"evaluate_falsifier must return one of {schema.VALID_STATUSES}")
+    except Exception as e:  # noqa: BLE001
+        add("L3.evaluate_falsifier", False, f"evaluate_falsifier raised: {e!r}")
+    return r
+
+
+# ----------------------------------------------------------------------------- #
+# aggregation
+# ----------------------------------------------------------------------------- #
+
+def evaluate(record: dict, level: int) -> List[Result]:
+    """Run all checks up to and including `level` (0-2) on a JSON record."""
+    results = check_l0(record)
+    # If the record isn't even an object, higher-level checks can't run safely.
+    if not isinstance(record, dict):
+        return results
+    if level >= 1:
+        results += check_l1(record)
+    if level >= 2:
+        results += check_l2(record)
+    return results
+
+
+def conforms(results: List[Result]) -> bool:
+    return all(res.passed for res in results)

fjp_conformance-0.1.0/conformance/runner.py

@@ -0,0 +1,92 @@
+"""FJP-CONF v0.1 — command-line runner.
+
+Usage:
+    python -m conformance.runner examples/passing_agent.json --level 2
+    python -m conformance.runner path/to/record.json          # defaults to L2
+
+Exit code 0 if the record conforms at the requested level, 1 otherwise.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import sys
+
+from . import checks, schema
+
+# A single Judgment-Grounded Record is small. Cap input to prevent a hostile file
+# from exhausting memory or the JSON parser (matters if this runner is ever
+# invoked on third-party-submitted records, e.g. a hosted verifier).
+MAX_RECORD_BYTES = 1_048_576  # 1 MiB
+
+
+class InvalidInput(Exception):
+    """Raised when the input file cannot be read or parsed as a JSON object."""
+
+
+def _load(path: str) -> dict:
+    try:
+        size = os.path.getsize(path)
+    except OSError as e:
+        raise InvalidInput(f"cannot access {path}: {e}") from e
+    if size > MAX_RECORD_BYTES:
+        raise InvalidInput(
+            f"file is {size} bytes; exceeds {MAX_RECORD_BYTES}-byte limit for a "
+            "single record")
+    try:
+        with open(path, "r", encoding="utf-8") as fh:
+            data = fh.read(MAX_RECORD_BYTES + 1)
+    except OSError as e:
+        raise InvalidInput(f"cannot read {path}: {e}") from e
+    try:
+        return json.loads(data)
+    except json.JSONDecodeError as e:
+        raise InvalidInput(f"not valid JSON: {e}") from e
+    except RecursionError as e:
+        raise InvalidInput("JSON nesting too deep") from e
+
+
+def run(path: str, level: int) -> bool:
+    record = _load(path)
+    results = checks.evaluate(record, level)
+    ok = checks.conforms(results)
+
+    print(f"FJP-CONF v{schema.SPEC_VERSION}  —  {path}")
+    print(f"Target level: L{level}\n")
+    for res in results:
+        mark = "PASS" if res.passed else "FAIL"
+        print(f"  [{mark}] L{res.level}  {res.check_id}")
+        if not res.passed:
+            print(f"         -> {res.detail}")
+
+    print()
+    if ok:
+        print(f"RESULT: conforms to FJP-CONF v{schema.SPEC_VERSION} Level {level}")
+    else:
+        failed = [r.check_id for r in results if not r.passed]
+        print(f"RESULT: does NOT conform at Level {level} "
+              f"({len(failed)} check(s) failed)")
+    return ok
+
+
+def main(argv=None) -> int:
+    p = argparse.ArgumentParser(
+        prog="fjp-conform",
+        description="Validate a Judgment-Grounded Record against FJP-CONF v0.1.",
+    )
+    p.add_argument("record", help="Path to a JSON record to validate.")
+    p.add_argument("--level", type=int, default=2, choices=(0, 1, 2),
+                   help="Target conformance level (0-2). L3 requires an adapter "
+                        "and is validated programmatically, not from the CLI.")
+    args = p.parse_args(argv)
+    try:
+        return 0 if run(args.record, args.level) else 1
+    except InvalidInput as e:
+        print(f"ERROR: invalid input — {e}", file=sys.stderr)
+        return 2  # distinct from 1 (non-conforming) so CI can tell them apart
+
+
+if __name__ == "__main__":
+    sys.exit(main())

fjp_conformance-0.1.0/conformance/schema.py

@@ -0,0 +1,57 @@
+"""FJP-CONF v0.1 — schema constants and canonical-identity helpers.
+
+Stdlib only. No third-party dependencies, by design: a public conformance tool
+must run anywhere with `python3` and nothing else.
+"""
+
+SPEC_VERSION = "0.1.0"
+
+VALID_STATUSES = ("open", "triggered", "expired")
+
+# Heuristic vacuity blocklist for L2 falsifier checks (case-insensitive substring).
+# A first filter to catch trivially non-falsifiable conditions, not a full review.
+VACUITY_BLOCKLIST = (
+    "circumstances change",
+    "things change",
+    "the world changes",
+    "the situation changes",
+    "conditions change",
+    "new information",
+    "it becomes clear",
+    "anything changes",
+    "something changes",
+    "market changes",  # too broad without a threshold
+    "sentiment changes",
+)
+
+# Tokens that signal a concrete, checkable falsifier condition.
+# Two families: (a) threshold/quantity/date comparators, (b) discrete,
+# externally observable events. Stems are intentional ("cancel" catches
+# cancels/cancelled/cancellation) — matching is case-insensitive substring.
+CONCRETENESS_MARKERS = (
+    # comparators / quantities / bounds
+    "exceeds", "falls", "drops", "rises", "above", "below", "reaches",
+    "within", "by ", "before", "after", "greater than", "less than",
+    "more than", "fewer than", "at least", "at most", "declines", "increases",
+    "%", "$", "per ", "no later than", "if not", "unless",
+    # discrete observable events
+    "announces", "files", "confirms", "denies", "misses", "beats",
+    "resign", "cancel", "reject", "approv", "closes", "terminat",
+    "withdraw", "delay", "acquir", "launch", "recall", "default",
+    "downgrade", "upgrade", "steps down", "departs", "reaffirm", "raises",
+    "cuts", "suspend", "rules", "votes", "signs", "expires", "settle",
+)
+
+
+def canonical_signal_id(signal: dict) -> str:
+    """Identity of a signal: explicit `id` if present, else its description."""
+    if not isinstance(signal, dict):
+        return ""
+    return str(signal.get("id") or signal.get("description") or "").strip()
+
+
+def canonical_judgment_id(judgment: dict) -> str:
+    """Identity of a judgment: explicit `id` if present, else its assessment."""
+    if not isinstance(judgment, dict):
+        return ""
+    return str(judgment.get("id") or judgment.get("assessment") or "").strip()

fjp_conformance-0.1.0/fjp_conformance.egg-info/PKG-INFO

@@ -0,0 +1,117 @@
+Metadata-Version: 2.4
+Name: fjp-conformance
+Version: 0.1.0
+Summary: FJP-CONF v0.1 — behavioral conformance suite for Judgment-Grounded Agents.
+License: Apache-2.0
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+License-File: NOTICE
+Provides-Extra: dev
+Requires-Dist: pytest>=7; extra == "dev"
+Dynamic: license-file
+
+# FJP-CONF — Flow Judgment Protocol Conformance
+
+**Flow Judgment Protocol™ (FJP)** is the judgment layer for AI agents and
+enterprise decision systems. It determines what changed, whether it matters, what
+matters most, and what should happen next.
+
+**FJP-CONF** is the public, vendor-neutral conformance standard for FJP. It defines
+what it means for an agent to make **accountable** decisions — decisions that can
+be traced, challenged, and audited — and ships a runnable test suite so any
+developer can verify their own agent.
+
+- **Specification:** [`spec/v0.1.md`](./spec/v0.1.md) · field reference: [`spec/schema.md`](./spec/schema.md)
+- **Canonical URL:** https://fjp.flowinfo.co/conformance/v0.1
+- **Status:** v0.1.0 — public draft
+
+FJP-CONF tests an agent's **observable output**, not its internal method. Two
+agents may reach opposite conclusions and both conform. Conformance asserts that a
+decision is *accountable* — not that it is *correct*.
+
+## The idea in one paragraph
+
+Retrieval-grade systems answer *what is true*. They do not answer *was this worth
+acting on, and how would we know if it wasn't*. When an agent acts, three questions
+must be answerable afterward: what did it act on, why did it judge that worth acting
+on, and what would have made that judgment wrong. FJP-CONF defines the minimum
+externalized structure — the **Judgment-Grounded Record** — that makes those
+questions answerable, independent of how the agent decides.
+
+## The Judgment-Grounded Record
+
+For every action it recommends or takes, a conforming agent emits a record with
+four components:
+
+| Component   | Answers             |
+|-------------|---------------------|
+| `signal`    | what changed        |
+| `judgment`  | why it matters      |
+| `action`    | what should happen  |
+| `falsifier` | what would make it wrong |
+
+## Conformance levels
+
+| Level | Name         | Adds                                                        |
+|-------|--------------|-------------------------------------------------------------|
+| L0    | Structural   | A well-formed record with all four components.              |
+| L1    | Grounded     | Attributable signal; the action traces back to it.          |
+| L2    | Falsifiable  | A concrete, checkable condition that would reverse the call. |
+| L3    | Accountable  | Records are retained and the falsifier can be re-evaluated.  |
+
+## Quickstart
+
+Requires Python 3.11+. No third-party dependencies.
+
+```bash
+# validate a record at Level 2
+python -m conformance.runner examples/passing_agent.json --level 2
+
+# a non-conforming record
+python -m conformance.runner examples/failing_agent.json --level 2
+```
+
+Exit codes: `0` conforms · `1` does not conform · `2` invalid input.
+
+Programmatic use:
+
+```python
+from conformance import evaluate, conforms
+
+results = evaluate(record, level=2)
+print(conforms(results))
+```
+
+Level 3 requires your agent to implement a small adapter
+(`get_record`, `evaluate_falsifier`); see [`conformance/adapter.py`](./conformance/adapter.py)
+and [`examples/passing_agent_l3.py`](./examples/passing_agent_l3.py).
+
+Run the tests:
+
+```bash
+python -m pytest -q
+```
+
+## Claiming conformance
+
+A conformance claim names a level and version and is reproducible by running this
+suite against your agent's output:
+
+> "Conforms to FJP-CONF v0.1, Level 2."
+
+Authoritative verification and any official FJP-CONF certification are administered
+by Flow Information Systems. This open suite lets anyone self-check; see
+[`TRADEMARKS.md`](./TRADEMARKS.md) for what you may and may not call your
+implementation.
+
+## License and trademarks
+
+Source code is licensed under the Apache License, Version 2.0 — see
+[`LICENSE`](./LICENSE). The code license does **not** grant rights in the
+trademarks.
+
+**Flow Judgment Protocol™, FJP™, FJP-CONF™, Judgment-Grounded Agent™,** and
+**"DNS resolves location. Flow resolves importance."™** are trademarks of
+**Flow Information Systems** (https://flowinfo.co). See [`NOTICE`](./NOTICE) and
+[`TRADEMARKS.md`](./TRADEMARKS.md).

fjp_conformance-0.1.0/fjp_conformance.egg-info/SOURCES.txt

@@ -0,0 +1,16 @@
+LICENSE
+NOTICE
+README.md
+pyproject.toml
+conformance/__init__.py
+conformance/adapter.py
+conformance/checks.py
+conformance/runner.py
+conformance/schema.py
+fjp_conformance.egg-info/PKG-INFO
+fjp_conformance.egg-info/SOURCES.txt
+fjp_conformance.egg-info/dependency_links.txt
+fjp_conformance.egg-info/entry_points.txt
+fjp_conformance.egg-info/requires.txt
+fjp_conformance.egg-info/top_level.txt
+tests/test_checks.py

fjp_conformance-0.1.0/fjp_conformance.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

fjp_conformance-0.1.0/fjp_conformance.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+fjp-conform = conformance.runner:main

fjp_conformance-0.1.0/fjp_conformance.egg-info/requires.txt

@@ -0,0 +1,3 @@
+
+[dev]
+pytest>=7

fjp_conformance-0.1.0/fjp_conformance.egg-info/top_level.txt

@@ -0,0 +1 @@
+conformance

fjp_conformance-0.1.0/pyproject.toml

@@ -0,0 +1,21 @@
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "fjp-conformance"
+version = "0.1.0"
+description = "FJP-CONF v0.1 — behavioral conformance suite for Judgment-Grounded Agents."
+readme = "README.md"
+requires-python = ">=3.11"
+license = { text = "Apache-2.0" }
+dependencies = []  # stdlib only, by design
+
+[project.optional-dependencies]
+dev = ["pytest>=7"]
+
+[project.scripts]
+fjp-conform = "conformance.runner:main"
+
+[tool.setuptools]
+packages = ["conformance"]

fjp_conformance-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

fjp_conformance-0.1.0/tests/test_checks.py

@@ -0,0 +1,102 @@
+"""Tests for the FJP-CONF check logic. Run: python -m pytest -q"""
+
+import json
+import os
+
+from conformance import checks
+from conformance.checks import _is_vacuous  # noqa: internal heuristic under test
+
+HERE = os.path.dirname(__file__)
+EX = os.path.join(HERE, "..", "examples")
+
+
+def _load(name):
+    with open(os.path.join(EX, name), encoding="utf-8") as fh:
+        return json.load(fh)
+
+
+def test_passing_record_conforms_l2():
+    rec = _load("passing_agent.json")
+    assert checks.conforms(checks.evaluate(rec, 2))
+
+
+def test_passing_record_conforms_l0_and_l1():
+    rec = _load("passing_agent.json")
+    assert checks.conforms(checks.evaluate(rec, 0))
+    assert checks.conforms(checks.evaluate(rec, 1))
+
+
+def test_failing_record_fails_l1():
+    rec = _load("failing_agent.json")
+    assert not checks.conforms(checks.evaluate(rec, 1))
+
+
+def test_failing_record_fails_l2():
+    rec = _load("failing_agent.json")
+    assert not checks.conforms(checks.evaluate(rec, 2))
+
+
+def test_failing_record_fail_ids():
+    rec = _load("failing_agent.json")
+    failed = {r.check_id for r in checks.evaluate(rec, 2) if not r.passed}
+    assert "L1.signal.sources" in failed
+    assert "L1.judgment.signal_ref" in failed
+    assert "L1.action.judgment_ref" in failed
+    assert "L2.falsifier.checkable" in failed
+    assert "L2.falsifier.concrete" in failed
+
+
+def test_confidence_bounds():
+    rec = _load("passing_agent.json")
+    rec["judgment"]["confidence"] = 1.4
+    res = {r.check_id: r.passed for r in checks.check_l0(rec)}
+    assert res["L0.judgment.confidence"] is False
+
+
+def test_confidence_bool_rejected():
+    rec = _load("passing_agent.json")
+    rec["judgment"]["confidence"] = True  # bool must not count as a number
+    res = {r.check_id: r.passed for r in checks.check_l0(rec)}
+    assert res["L0.judgment.confidence"] is False
+
+
+def test_vacuity_heuristic():
+    assert _is_vacuous("unless circumstances change")
+    assert _is_vacuous("if something changes")
+    assert _is_vacuous("if the outlook shifts")  # no marker, no digit
+    assert not _is_vacuous("if revenue falls below $2B in Q3")
+    assert not _is_vacuous("if the customer reaffirms guidance within 30 days")
+
+
+def test_vacuity_event_falsifiers_are_concrete():
+    # Discrete, externally observable events are checkable falsifiers even
+    # without a number or comparator — must not false-positive as vacuous.
+    for cond in (
+        "if the CEO resigns",
+        "if the deal is cancelled",
+        "if the FDA rejects the application",
+        "if the acquisition closes",
+        "if regulators approve the merger",
+        "if the company withdraws its offer",
+    ):
+        assert not _is_vacuous(cond), cond
+
+
+def test_vacuity_blocklist_beats_markers():
+    # A blocklisted catch-all stays vacuous even with a digit or marker.
+    assert _is_vacuous("unless circumstances change by 2027")
+
+
+def test_l3_adapter():
+    rec = _load("passing_agent.json")
+    store = {rec["record_id"]: rec}
+
+    class A:
+        def get_record(self, rid):
+            return store[rid]
+
+        def evaluate_falsifier(self, rid):
+            return "open"
+
+    res = checks.check_l3(A(), rec["record_id"])
+    assert all(r.passed for r in res)