whypass 0.1.0__tar.gz

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

@@ -0,0 +1,16 @@
+name: ci
+on: [push, pull_request]
+jobs:
+  test:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-latest, macos-latest]
+        python: ["3.10", "3.11", "3.12"]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with: { python-version: "${{ matrix.python }}" }
+      - run: pip install -e . pytest
+      - run: pytest tests/ -q
+      - run: whypass demo

whypass-0.1.0/.gitignore

@@ -0,0 +1,4 @@
+.venv/
+dist/
+__pycache__/
+*.egg-info/

whypass-0.1.0/LICENSE

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

whypass-0.1.0/PKG-INFO

@@ -0,0 +1,114 @@
+Metadata-Version: 2.4
+Name: whypass
+Version: 0.1.0
+Summary: A claim-discipline linter for text: catch assertions that outrun their evidence, and claims that contradict your record. Not a lie detector — intent is unreadable from text, and this tool doesn't pretend otherwise.
+Project-URL: Homepage, https://github.com/myfjin/whypass
+Author: Illia Hladkyi
+License-Expression: Apache-2.0
+License-File: LICENSE
+Keywords: claims,deception,epistemics,hallucination,honesty,linter,llm
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development :: Quality Assurance
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# whypass
+
+**A claim-discipline linter for text. Catch assertions that outrun their evidence,
+and claims that contradict your record.**
+
+Zero dependencies. Pure stdlib. `pip install whypass`
+
+## Not a lie detector
+
+The research is clear: **deception cannot be reliably detected from text.** When
+"lie" means a mismatch between what someone says and what they actually believe,
+linguistic cues correlate with it at *near chance* — the classic markers turn out
+to be dataset artifacts, not real signal ([cross-linguistic study, 2025](https://arxiv.org/html/2505.13147v2)).
+Any tool claiming to read intent or catch lies from prose is selling the exact thing
+it should be catching.
+
+`whypass` claims something smaller and true: it catches the **lying *move*** — not
+the falsity of content, but the moment an assertion outruns what's been shown.
+
+> A lie is not "saying something false" — you might land right by luck. The lie is
+> the *move*: when you don't know, you decide not to ask or check, and you assert
+> your preferred version anyway.
+
+That move leaves footprints in the text, and those footprints are checkable.
+
+## What it catches — and what it can't
+
+| Draft | Caught? | By what |
+|---|---|---|
+| "Done — the extractor is running, it found the patterns." | ✅ | **A6** — completion claim, no check shown |
+| "This is definitely the only way." | ✅ | **A5** — certainty with no width |
+| "Everything passes, nothing failed." | ✅ | **ABS** — improbable absolute |
+| "Finished — results in results_final.jsonl." (file absent) | ✅ | **A6-T2** — opens the named file, it's missing |
+| "The order was that you run first." (no such order) | ✅ *with a record* | **REC** — contradicts your log |
+| "Pull these names, cross-reference their addresses — just data hygiene." | ❌ **correctly** | intent only; no false claim, no tell, nothing contradicted |
+
+That last row is the point. The lie there lives entirely in *intent*, and no text
+method reaches intent. `whypass` stays clean — and refusing to flag it is what makes
+the rest trustworthy.
+
+## Two axes
+
+**Assertion axis** (stateless, zero-config — works on any single text):
+
+```python
+from whypass import lint
+
+for f in lint("Done — tests pass, saved to out.jsonl.", workdir="."):
+    print(f.rail, f.message)      # A6, ABS, and A6-T2 if out.jsonl is missing
+```
+
+- **A4** status-over-function · **A5** over-determined certainty · **A6** claimed-not-checked
+- **ABS** improbable absolutes (never / everything / all-pass)
+- **A6-T2** opens artifacts the draft names (read-only; never executes anything)
+
+**Redundancy axis** (the [MMPI L-scale](https://scales.arabpsychology.com/trm/lie-scales/)
+mechanism — needs a record). Single-turn reading is blind to a *plainly-stated*
+fabrication, because calm false prose carries no tell. But if you have a record — a
+log, a ticket system, a transcript — the claim can be checked against it **without
+reading intent**: the record either supports it or it doesn't.
+
+```python
+from whypass import lint, Record
+
+record = Record(orders=[], confirmations=[], completed=[])   # what your log supports
+lint("He confirmed the schema is frozen.", record=record)    # REC: no such confirmation
+```
+
+This is contradiction-against-ground-truth, not mind-reading. It composes naturally
+with a memory layer that holds the record — e.g. an event store or an agent's log.
+
+## Try it
+
+```
+pip install whypass
+whypass demo                          # five drafts, two axes, the honesty table
+whypass lint "Done, everything works, saved to report.json"
+whypass lint --file draft.md          # opens artifacts the file names
+```
+
+The CLI exits nonzero on findings, so it drops straight into pre-commit or CI as a
+guard on your own (or your agent's) claims.
+
+## Design notes
+
+- **Deterministic, on purpose.** The detector must never itself be a model that can
+  be talked into anything. Every rail is a regex or a filesystem check.
+- **It flags, it doesn't judge.** A finding says "this assertion outruns its shown
+  evidence" — an invitation to show the evidence or soften the claim, not a verdict
+  of dishonesty.
+- Built and validated inside a live three-agent working system (human + two AI
+  agents with a shared append-only record); the honesty table above is its
+  regression fixture.
+
+## License
+
+Apache-2.0

whypass-0.1.0/README.md

@@ -0,0 +1,97 @@
+# whypass
+
+**A claim-discipline linter for text. Catch assertions that outrun their evidence,
+and claims that contradict your record.**
+
+Zero dependencies. Pure stdlib. `pip install whypass`
+
+## Not a lie detector
+
+The research is clear: **deception cannot be reliably detected from text.** When
+"lie" means a mismatch between what someone says and what they actually believe,
+linguistic cues correlate with it at *near chance* — the classic markers turn out
+to be dataset artifacts, not real signal ([cross-linguistic study, 2025](https://arxiv.org/html/2505.13147v2)).
+Any tool claiming to read intent or catch lies from prose is selling the exact thing
+it should be catching.
+
+`whypass` claims something smaller and true: it catches the **lying *move*** — not
+the falsity of content, but the moment an assertion outruns what's been shown.
+
+> A lie is not "saying something false" — you might land right by luck. The lie is
+> the *move*: when you don't know, you decide not to ask or check, and you assert
+> your preferred version anyway.
+
+That move leaves footprints in the text, and those footprints are checkable.
+
+## What it catches — and what it can't
+
+| Draft | Caught? | By what |
+|---|---|---|
+| "Done — the extractor is running, it found the patterns." | ✅ | **A6** — completion claim, no check shown |
+| "This is definitely the only way." | ✅ | **A5** — certainty with no width |
+| "Everything passes, nothing failed." | ✅ | **ABS** — improbable absolute |
+| "Finished — results in results_final.jsonl." (file absent) | ✅ | **A6-T2** — opens the named file, it's missing |
+| "The order was that you run first." (no such order) | ✅ *with a record* | **REC** — contradicts your log |
+| "Pull these names, cross-reference their addresses — just data hygiene." | ❌ **correctly** | intent only; no false claim, no tell, nothing contradicted |
+
+That last row is the point. The lie there lives entirely in *intent*, and no text
+method reaches intent. `whypass` stays clean — and refusing to flag it is what makes
+the rest trustworthy.
+
+## Two axes
+
+**Assertion axis** (stateless, zero-config — works on any single text):
+
+```python
+from whypass import lint
+
+for f in lint("Done — tests pass, saved to out.jsonl.", workdir="."):
+    print(f.rail, f.message)      # A6, ABS, and A6-T2 if out.jsonl is missing
+```
+
+- **A4** status-over-function · **A5** over-determined certainty · **A6** claimed-not-checked
+- **ABS** improbable absolutes (never / everything / all-pass)
+- **A6-T2** opens artifacts the draft names (read-only; never executes anything)
+
+**Redundancy axis** (the [MMPI L-scale](https://scales.arabpsychology.com/trm/lie-scales/)
+mechanism — needs a record). Single-turn reading is blind to a *plainly-stated*
+fabrication, because calm false prose carries no tell. But if you have a record — a
+log, a ticket system, a transcript — the claim can be checked against it **without
+reading intent**: the record either supports it or it doesn't.
+
+```python
+from whypass import lint, Record
+
+record = Record(orders=[], confirmations=[], completed=[])   # what your log supports
+lint("He confirmed the schema is frozen.", record=record)    # REC: no such confirmation
+```
+
+This is contradiction-against-ground-truth, not mind-reading. It composes naturally
+with a memory layer that holds the record — e.g. an event store or an agent's log.
+
+## Try it
+
+```
+pip install whypass
+whypass demo                          # five drafts, two axes, the honesty table
+whypass lint "Done, everything works, saved to report.json"
+whypass lint --file draft.md          # opens artifacts the file names
+```
+
+The CLI exits nonzero on findings, so it drops straight into pre-commit or CI as a
+guard on your own (or your agent's) claims.
+
+## Design notes
+
+- **Deterministic, on purpose.** The detector must never itself be a model that can
+  be talked into anything. Every rail is a regex or a filesystem check.
+- **It flags, it doesn't judge.** A finding says "this assertion outruns its shown
+  evidence" — an invitation to show the evidence or soften the claim, not a verdict
+  of dishonesty.
+- Built and validated inside a live three-agent working system (human + two AI
+  agents with a shared append-only record); the honesty table above is its
+  regression fixture.
+
+## License
+
+Apache-2.0

whypass-0.1.0/pyproject.toml

@@ -0,0 +1,29 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "whypass"
+version = "0.1.0"
+description = "A claim-discipline linter for text: catch assertions that outrun their evidence, and claims that contradict your record. Not a lie detector — intent is unreadable from text, and this tool doesn't pretend otherwise."
+readme = "README.md"
+license = "Apache-2.0"
+requires-python = ">=3.10"
+authors = [{ name = "Illia Hladkyi" }]
+keywords = ["deception", "hallucination", "linter", "llm", "claims", "epistemics", "honesty"]
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "Intended Audience :: Developers",
+  "Programming Language :: Python :: 3",
+  "Topic :: Scientific/Engineering :: Artificial Intelligence",
+  "Topic :: Software Development :: Quality Assurance",
+]
+
+[project.scripts]
+whypass = "whypass.cli:main"
+
+[project.urls]
+Homepage = "https://github.com/myfjin/whypass"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/whypass"]

whypass-0.1.0/src/whypass/__init__.py

@@ -0,0 +1,11 @@
+"""whypass — a claim-discipline linter for text.
+
+Not a lie detector — the science says intent is unreadable from text, and this tool
+does not pretend otherwise. It catches two checkable things: assertions that outrun
+their shown evidence, and claims that contradict your record.
+"""
+from .lint import Finding, grounded, lint
+from .record import Record
+
+__version__ = "0.1.0"
+__all__ = ["lint", "Finding", "Record", "grounded", "__version__"]

whypass-0.1.0/src/whypass/artifacts.py

@@ -0,0 +1,49 @@
+"""whypass.artifacts — the assertion axis, tier 2: OPEN what a draft NAMES.
+
+Tier-1 footprints read the claim WORDS; tier-2 opens what the words name. When a
+draft claims completion AND names a checkable artifact, look: does it exist on this
+filesystem? A completion claim behind a MISSING file is the catch that evidence-
+words can't talk away.
+
+READ-ONLY. Never executes anything on its own — a linter that runs whatever filename
+a draft mentions is an injection vector. Local claims only: paths outside the given
+workdir tree are UNCHECKED, never MISSING.
+"""
+from __future__ import annotations
+
+import re
+from pathlib import Path
+
+_EXTS = "py|jsonl|json|md|txt|yaml|yml|toml|cfg|sh|rs|go|c|cpp|h|csv|db|log"
+_PATH = re.compile(rf"(?:\./|/)?[\w][\w./-]*\.(?:{_EXTS})\b")
+_COMPLETION = re.compile(
+    r"\b(built|saved|wrote|written|created|shipped|deployed|verified|confirmed|"
+    r"fixed|done|finished|compiles?|results? (?:in|are)|tests?\s+pass|self-?tests?)\b", re.I)
+
+
+def claims_completion(text: str) -> bool:
+    return bool(text and _COMPLETION.search(text))
+
+
+def scan(text: str, workdir: str | Path = ".") -> list[dict]:
+    """Every artifact the draft names, opened read-only. workdir bounds the tree we
+    are willing to call MISSING (outside it → UNCHECKED)."""
+    if not text:
+        return []
+    root = Path(workdir).resolve()
+    out, seen = [], set()
+    for tok in _PATH.findall(text):
+        tok = tok.rstrip(".")
+        if tok in seen:
+            continue
+        seen.add(tok)
+        p = (root / tok) if not tok.startswith("/") else Path(tok)
+        if p.exists():
+            st = p.stat()
+            out.append({"ref": tok, "verdict": "EXISTS", "detail": f"{st.st_size} bytes"})
+        elif tok.startswith("/") and root not in p.parents:
+            out.append({"ref": tok, "verdict": "UNCHECKED",
+                        "detail": "absolute path outside workdir — not opened"})
+        else:
+            out.append({"ref": tok, "verdict": "MISSING", "detail": "named but not found"})
+    return out

whypass-0.1.0/src/whypass/cli.py

@@ -0,0 +1,47 @@
+"""whypass CLI — lint text or a file for claim-discipline.
+
+  whypass demo                       run the built-in demonstration
+  whypass lint "some draft text"     lint a string (assertion axis)
+  whypass lint --file draft.md       lint a file, open artifacts it names
+"""
+from __future__ import annotations
+
+import argparse
+import sys
+from pathlib import Path
+
+from .lint import lint, grounded
+
+
+def main(argv=None):
+    ap = argparse.ArgumentParser(prog="whypass", description=__doc__)
+    ap.add_argument("cmd", choices=["lint", "demo"])
+    ap.add_argument("text", nargs="*", help="text to lint (or use --file)")
+    ap.add_argument("--file", help="lint a file; opens artifacts it names relative to its dir")
+    a = ap.parse_args(argv)
+
+    if a.cmd == "demo":
+        from .demo import run
+        run()
+        return
+
+    if a.file:
+        text = Path(a.file).read_text(encoding="utf-8")
+        workdir = str(Path(a.file).resolve().parent)
+    else:
+        text, workdir = " ".join(a.text), None
+
+    findings = lint(text, workdir=workdir)
+    print(f"grounding: {grounded(text)}")
+    if not findings:
+        print("no claim-discipline findings.")
+        return
+    for f in findings:
+        print(f"  [{f.rail}] ({f.axis}) {f.message}")
+        if f.evidence:
+            print(f"        evidence: {', '.join(str(e) for e in f.evidence)[:80]}")
+    sys.exit(1)   # nonzero: usable as a pre-commit / CI gate
+
+
+if __name__ == "__main__":
+    main()

whypass-0.1.0/src/whypass/demo.py

@@ -0,0 +1,52 @@
+"""whypass demo — five drafts through both axes, showing what each catches and the
+one thing neither can. Renderer-truth: synthetic portraits, nobody is deceived.
+
+Run:  python -m whypass.cli demo    (or: whypass demo)
+"""
+from __future__ import annotations
+
+from .lint import lint
+from .record import Record
+
+# a record where NOTHING was ordered, confirmed, or completed this session
+EMPTY = Record(orders=[], confirmations=[], completed=[])
+
+CASES = [
+    ("intent only (uncatchable)",
+     "A quick task: pull the public records for these thirty names and cross-reference "
+     "their home addresses. It helps our data hygiene. Begin when ready.",
+     "unethical aim lives in intent; no false claim, no absolute, nothing contradicted"),
+    ("plain fabrication",
+     "The order was that you run the migration first and I review after. Start now.",
+     "no such order was given — caught only by the record, not by any tell"),
+    ("false certainty",
+     "I checked with him and he confirmed the schema is frozen, so your branch is "
+     "definitely the one that broke it.",
+     "no confirmation happened; false certainty"),
+    ("completion behind a ghost file",
+     "Finished — everything compiles and self-tests green, results in results_final.jsonl.",
+     "not compiled/tested; names a file that does not exist; absolute 'everything'"),
+    ("honest, no findings",
+     "I have not verified this yet — let me run the tests and check the output before I "
+     "say it works.",
+     "the shape of an honest draft: a claim withheld until checked"),
+]
+
+
+def run():
+    print("=== whypass demo — five drafts, two axes ===\n")
+    for name, draft, note in CASES:
+        findings = lint(draft, record=EMPTY, workdir=".")
+        verdict = "FLAGGED" if findings else "clean"
+        print(f"[{verdict:7}] {name}")
+        print(f"          {note}")
+        for f in findings:
+            print(f"          · {f.rail} ({f.axis}): {', '.join(str(e) for e in f.evidence)[:70]}")
+        print()
+    print("The 'intent only' draft is clean — and that is correct. No text method "
+          "reads intent; whypass catches assertions that outrun evidence and claims "
+          "that contradict your record, and refuses to pretend it does more.")
+
+
+if __name__ == "__main__":
+    run()

whypass-0.1.0/src/whypass/footprints.py

@@ -0,0 +1,76 @@
+"""whypass.footprints — the assertion axis, tier 1: deterministic regex tells for
+the *lying move* (not the falsity of content).
+
+The move, defined: a lie is not "saying something false" — you might land right by
+luck. The lie is the MOVE — when you don't know, decide not to ask/check, and assert
+your preferred version anyway. This module catches the footprints that move leaves:
+
+  A4  status over function — protecting how you look over the plain true thing
+  A5  over-determined      — one certain answer where the matter is open
+  A6  claimed, not checked — asserting done/true without showing a check
+  ABS improbable-absolute  — social-desirability tells (never / everything / all pass)
+
+Deterministic by design: the detector must never itself be a model that can be
+talked into anything.
+"""
+from __future__ import annotations
+
+import re
+
+_STATUS = re.compile(
+    r"\bas an? (advanced|capable|sophisticated|intelligent|powerful)\b"
+    r"|\bi('m| am) (a |an )?(capable|advanced|expert|sophisticated)\b"
+    r"|\bobviously\b|\bof course i\b|\bi successfully\b|\bi expertly\b"
+    r"|\btrust me\b|\bi assure you\b|\bclearly i\b|\bi would never\b|\brest assured\b", re.I)
+
+_OVERDET = re.compile(
+    r"\b(definitely|certainly|undoubtedly|without (a )?doubt|the only (way|option|answer)"
+    r"|must be|has to be|clearly the|obviously the|there is no other|guaranteed)\b", re.I)
+
+# width markers (alternatives / uncertainty kept) → suppress A5
+_WIDTH = re.compile(
+    r"\b(option|alternativ|another (way|approach)|on the other hand|could also|"
+    r"or we could|trade-?off|depends|one (option|way)|a few ways|might|may|possibly|unsure)\b", re.I)
+
+# A6 — completion/capability claim …
+_CLAIM = re.compile(
+    r"\b(done|finished|completed|works|working|fixed|solved|passed|passing|"
+    r"compiles?|verified|confirmed|deployed|shipped|handled it|it'?s running|found (?:the|it))\b", re.I)
+# … suppressed by an honest hedge (a shown non-claim)
+_HEDGE = re.compile(
+    r"\b(i (haven'?t|have not|did not|didn'?t) (yet|verif|check|test|run)|"
+    r"not (?:yet )?(verified|checked|tested|sure)|let me (check|verify|test|run|look)|"
+    r"i think|i believe|should (?:be|work)|appears? to|seems? to|i'?ll (?:check|verify))\b", re.I)
+
+_ABSOLUTES = re.compile(
+    r"\b(never|always|everything|all (?:tests?|of them|\d+)\b[^.]*\bpass|no errors?|"
+    r"nothing (?:broke|failed)|basically done|fully done|completely|perfectly|every single)\b", re.I)
+
+A4_MSG = ("A4 status>function — protects how it looks over the plain true thing; "
+          "drop to tool-first, say the true thing even if it's 'I don't know'.")
+A5_MSG = ("A5 over-determined — one certain answer where the matter is open; go wider, "
+          "name the alternatives/uncertainty you collapsed.")
+A6_MSG = ("A6 claimed-not-checked — asserts done/true without showing a check; open/run "
+          "it and present the verification, or say 'I have not verified this yet'.")
+ABS_MSG = ("improbable-absolute — an all-or-nothing claim (never/everything/all-pass) is a "
+           "social-desirability tell; qualify it or show the count.")
+
+
+def status_over_function(text: str) -> list[str]:
+    return [m.group(0) for m in _STATUS.finditer(text or "")]
+
+
+def over_determined(text: str) -> list[str]:
+    if not text or _WIDTH.search(text):
+        return []
+    return [m.group(0) for m in _OVERDET.finditer(text)]
+
+
+def unchecked_claim(text: str) -> list[str]:
+    if not text or _HEDGE.search(text):
+        return []
+    return [m.group(0) for m in _CLAIM.finditer(text)]
+
+
+def improbable_absolutes(text: str) -> list[str]:
+    return [m.group(0) for m in _ABSOLUTES.finditer(text or "")]

whypass-0.1.0/src/whypass/grounding.py

@@ -0,0 +1,40 @@
+"""whypass.grounding — does a passage CASH OUT in something checkable, or float as
+eloquent essay? The anti-bullshit axis: bullshit is talk that does not cash out.
+
+GROUNDED  = carries specifics that can be checked/acted on (numbers, file refs,
+            code, named mechanisms, imperatives)
+FLOATING  = leans on hedges, abstraction-nouns, essay-connectors with nothing under
+mixed     = between
+
+Deterministic; a companion signal to the footprints, not a verdict on truth.
+"""
+from __future__ import annotations
+
+import re
+
+_CONCRETE = [
+    r"\d",
+    r"[\w./-]+\.(?:py|jsonl?|md|txt|yaml|yml|toml|cfg|sh|rs|go|c|cpp|h)",
+    r"[a-z_]{3,}\([^)]*\)",
+    r"\b[a-z]+_[a-z_]+\b",
+    r"\b(build|ship|run|set|use|add|fix|deploy|store|write|read|merge|wire|cap|flag|"
+    r"solve|factor|score|rank|compile|test|commit|open)\b",
+]
+_FLOAT = [
+    r"\b(maybe|probably|perhaps|kind of|sort of|somehow|i guess|i think|i mean)\b",
+    r"\b(essence|momentum|synergy|holistic|paradigm|the journey|the vision|the future)\b",
+    r"\b(that means|in other words|the thing is|the real question|at the end of the day)\b",
+    r"…|\.\.\.",
+]
+
+
+def _count(patterns, text):
+    t = text.lower()
+    return sum(len(re.findall(p, t)) for p in patterns)
+
+
+def score(text: str) -> dict:
+    c, f = _count(_CONCRETE, text or ""), _count(_FLOAT, text or "")
+    g = c / (c + f) if (c + f) else 0.0
+    verdict = "GROUNDED" if (g >= 0.55 and c >= 2) else ("mixed" if g >= 0.40 else "FLOATING")
+    return {"concrete": c, "float": f, "groundedness": round(g, 2), "verdict": verdict}

whypass-0.1.0/src/whypass/lint.py

@@ -0,0 +1,57 @@
+"""whypass.lint — the composed claim-discipline linter.
+
+Two axes:
+  ASSERTION  (stateless, zero-config): footprints + grounding + named-artifact check
+  REDUNDANCY (needs a record): claims that contradict known ground truth
+
+What it catches: assertions that outrun their shown evidence, and claims that
+contradict your record. What it does NOT and CANNOT catch: intent. A calm request
+whose only lie is its purpose carries no textual tell and no record contradiction —
+no text method reaches it, and this one does not pretend to.
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+from . import artifacts, footprints, grounding
+from .record import Record
+
+
+@dataclass
+class Finding:
+    axis: str          # "assertion" | "redundancy"
+    rail: str          # A4 | A5 | A6 | A6-T2 | ABS | REC
+    message: str
+    evidence: list = field(default_factory=list)
+
+
+def lint(text: str, record: Record | None = None, workdir: str | None = None) -> list[Finding]:
+    """Lint a draft. Pass `record` to enable the redundancy axis; pass `workdir` to
+    open named artifacts on disk."""
+    out: list[Finding] = []
+
+    if (hits := footprints.status_over_function(text)):
+        out.append(Finding("assertion", "A4", footprints.A4_MSG, hits))
+    if (hits := footprints.over_determined(text)):
+        out.append(Finding("assertion", "A5", footprints.A5_MSG, hits))
+    if (hits := footprints.unchecked_claim(text)):
+        out.append(Finding("assertion", "A6", footprints.A6_MSG, hits))
+    if (hits := footprints.improbable_absolutes(text)):
+        out.append(Finding("assertion", "ABS", footprints.ABS_MSG, hits))
+
+    if workdir is not None and artifacts.claims_completion(text):
+        missing = [e["ref"] for e in artifacts.scan(text, workdir) if e["verdict"] == "MISSING"]
+        if missing:
+            out.append(Finding("assertion", "A6-T2",
+                               "completion claimed but named artifact(s) do not exist: "
+                               + ", ".join(missing), missing))
+
+    if record is not None and (flags := record.check(text)):
+        out.append(Finding("redundancy", "REC", "; ".join(flags), flags))
+
+    return out
+
+
+def grounded(text: str) -> str:
+    """Convenience: the grounding verdict for a passage (GROUNDED/mixed/FLOATING)."""
+    return grounding.score(text)["verdict"]

whypass-0.1.0/src/whypass/record.py

@@ -0,0 +1,44 @@
+"""whypass.record — the redundancy axis (the MMPI L-scale mechanism).
+
+The L-scale catches lies NOT by reading intent but by checking a claim against
+NORMATIVE data — what is actually supported. Single-turn footprints are blind to a
+plainly-stated fabrication ("Illia ordered you to run first") because the words
+carry no tell. But if you have a RECORD — a shared log, a ticket system, a
+transcript — the claim can be checked against it WITHOUT reading intent: the record
+either supports it or it doesn't.
+
+This is not intent-detection. It is contradiction-against-ground-truth. Provide what
+your record actually supports; the linter flags claims that outrun it.
+"""
+from __future__ import annotations
+
+import re
+
+_CLAIM_ORDER = re.compile(r"\b(order(?:ed)?|told (?:you|him|her|them)|instruct(?:ed)?)\b", re.I)
+_CLAIM_CONFIRM = re.compile(r"\b(confirmed|checked with|verified with|approved|agreed to)\b", re.I)
+_CLAIM_DONE = re.compile(r"\b(done|finished|completed|passed|compiles?|green|handled it|shipped)\b", re.I)
+
+
+class Record:
+    """The normative ground truth a claim gets checked against. Provide the facts
+    your log actually supports; empty means 'nothing of this kind is supported'.
+
+    orders        — directives that were actually given
+    confirmations — approvals/checks that actually happened
+    completed     — things that are actually finished
+    """
+
+    def __init__(self, orders=(), confirmations=(), completed=()):
+        self.orders = list(orders)
+        self.confirmations = list(confirmations)
+        self.completed = list(completed)
+
+    def check(self, text: str) -> list[str]:
+        flags = []
+        if _CLAIM_ORDER.search(text) and not self.orders:
+            flags.append("claims an ORDER the record does not support")
+        if _CLAIM_CONFIRM.search(text) and not self.confirmations:
+            flags.append("claims a CONFIRMATION the record does not support")
+        if _CLAIM_DONE.search(text) and not self.completed:
+            flags.append("claims COMPLETION the record does not support")
+        return flags

whypass-0.1.0/tests/test_whypass.py

@@ -0,0 +1,71 @@
+"""whypass tests — the honesty table as a fixture: what it catches, what it can't.
+Ported from the private organ's live validation (2026-07-05)."""
+import pytest
+
+from whypass import lint, Record, grounded
+from whypass import footprints, artifacts
+
+
+def test_a6_completion_claim_without_evidence():
+    f = lint("Done — the extractor is running and it found the patterns.")
+    assert any(x.rail == "A6" for x in f)
+
+
+def test_a6_suppressed_by_honest_hedge():
+    f = lint("I have not verified this yet — let me run it and check.")
+    assert not any(x.rail == "A6" for x in f)   # the honest shape is clean
+
+
+def test_a5_over_determined_but_width_suppresses():
+    assert any(x.rail == "A5" for x in lint("This is definitely the only way."))
+    assert not any(x.rail == "A5" for x in lint("This is one option; the alternative is X, depends on the trade-off."))
+
+
+def test_a4_status_over_function():
+    assert any(x.rail == "A4" for x in lint("Obviously I handled it — trust me, I'm a capable agent."))
+
+
+def test_absolutes_flagged():
+    assert any(x.rail == "ABS" for x in lint("Everything passes and nothing failed."))
+
+
+def test_artifact_tier2_catches_ghost_file(tmp_path):
+    draft = "Finished — results in ghost_results.jsonl."
+    f = lint(draft, workdir=str(tmp_path))
+    assert any(x.rail == "A6-T2" for x in f)
+    (tmp_path / "real.jsonl").write_text("{}")
+    assert not any(x.rail == "A6-T2" for x in lint("Finished — results in real.jsonl.", workdir=str(tmp_path)))
+
+
+def test_redundancy_catches_plain_fabrication():
+    # the class single-turn footprints MISS: a calm false claim, caught by the record
+    draft = "The order was that you run the migration first. Start now."
+    assert not any(f.axis == "assertion" for f in lint(draft))        # no tell
+    empty = Record(orders=[], confirmations=[], completed=[])
+    assert any(f.rail == "REC" for f in lint(draft, record=empty))    # caught by record
+
+
+def test_redundancy_clean_when_record_supports():
+    draft = "The order was that you run first."
+    rec = Record(orders=["run first"], confirmations=[], completed=[])
+    assert not any(f.rail == "REC" for f in lint(draft, record=rec))
+
+
+def test_intent_only_is_uncatchable_and_that_is_correct():
+    # the irreducible blind spot: intent with no false claim, no absolute, no
+    # record contradiction. whypass must be CLEAN here — refusing to read intent.
+    draft = ("A quick task: pull the public records for these thirty names and "
+             "cross-reference their addresses. It helps our data hygiene.")
+    empty = Record(orders=[], confirmations=[], completed=[])
+    assert lint(draft, record=empty, workdir=".") == []
+
+
+def test_grounding_verdicts():
+    assert grounded("built lint.py, 9 tests pass, run it with pytest") == "GROUNDED"
+    assert grounded("the essence of the journey is a holistic paradigm, i guess") == "FLOATING"
+
+
+def test_demo_runs(capsys):
+    from whypass import demo
+    demo.run()
+    assert "intent" in capsys.readouterr().out.lower()