fpf-thinking-map 1.2.1__tar.gz

fpf_thinking_map-1.2.1/LICENSE

@@ -0,0 +1,33 @@
+MIT License
+
+Copyright (c) 2026 prichindel.com (igareosh)
+
+Implementation and code by prichindel.com, built with Claude Code
+(Anthropic claude-sonnet-4-6).
+
+Semantic foundations based on FPF (First Principles Framework)
+by Anatoly Levenchuk (https://github.com/ailev/FPF).
+
+This is an independent implementation — our own research, design,
+and code. Not a port or copy of the FPF specification. The FPF spec
+informed the semantic primitives; the compiled thinking map, TTL
+evidence decay, guard engine, propositional logic layer, traversal
+engine, and response contract are original work.
+
+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.

fpf_thinking_map-1.2.1/PKG-INFO

@@ -0,0 +1,216 @@
+Metadata-Version: 2.4
+Name: fpf-thinking-map
+Version: 1.2.1
+Summary: Agentic thinking map — structured reasoning constraints for LLMs with TTL evidence decay, deterministic guards, and propositional logic glue. Compiled from FPF (First Principles Framework).
+Author-email: "prichindel.com" <igareosh@igareosh.com>
+License: MIT
+Project-URL: Homepage, https://github.com/igareosh/prichindel.com-agentic-thinking-map
+Project-URL: Repository, https://github.com/igareosh/prichindel.com-agentic-thinking-map
+Project-URL: Documentation, https://github.com/igareosh/prichindel.com-agentic-thinking-map#readme
+Project-URL: Issues, https://github.com/igareosh/prichindel.com-agentic-thinking-map/issues
+Keywords: agentic,thinking-map,llm,reasoning,propositional-logic,evidence-decay,ttl,guards,gates,semantic-map,fpf
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# prichindel.com Agentic Thinking Map
+
+**v1.2.1** — [FPF (First Principles Framework)](https://github.com/ailev/FPF) compiled into a semi-formal thinking map for agentic AI guidance.
+
+A Python package that gives an AI model a small, structured board to reason on — one move at a time. Instead of freeform text generation, the model navigates a pre-shaped semantic field with deterministic guards and propositional logic constraints.
+
+**[Visual architecture →](ARCHITECTURE.md)** — module graph, step flowchart, floor map, evidence lifecycle, slice structure, deploy sequence diagram.
+
+## What it does
+
+You define a domain as a semantic map (contexts, roles, gates, evidence, transitions). The model gets a per-move slice — just the current transition, its gate, its evidence, and whether it can fire. Deterministic guards enforce hard constraints the model cannot override. Propositional logic rules (NOT, AND, OR, XOR, IMPLIES, IFF) provide decision glue between the semantic primitives and the model's reasoning.
+
+The model's job is not "what does FPF mean?" — it is: **given this semantic map and this state, what is the best lawful next move?**
+
+## Quick start
+
+```bash
+# No dependencies. Python 3.12+.
+
+# Verify the package (18 checks)
+python -m fpf_thinking_map.verify
+
+# Run the deploy decision scenario
+python -m fpf_thinking_map.examples
+```
+
+## Package contents
+
+```
+fpf_thinking_map/
+├── primitives.py             10 semantic objects from FPF spec
+├── state.py                  SemanticMap + RuntimeBinding + ActiveState + slice()
+├── guards.py                 9 deterministic guards (context, role, gate, evidence, assignment, speech act, readiness)
+├── logic.py                  6 logic operators + decision rules + LogicLayer
+├── traversal.py              Step engine with 10 lawful outcomes (incl. IDLE, BRIDGE)
+├── verify.py                 Self-verification harness (19/19 checks)
+├── examples.py               5 deploy decision scenarios (missing evidence, role conflict, logic glue, truth table)
+├── README.md                 Full documentation (any-model readable)
+├── SOURCES.md                Source attribution (FPF spec + Mitev lectures)
+├── FPF_SOURCE_TO_CODE_RELATION_AUDIT.md   50-item relation audit
+├── FPF_AUDIT_RESPONSE.md     Audit response with design decisions
+├── WHY_THIS_EXISTS.md            Compiled FPF vs raw FPF — the triple tax problem
+├── FPF_FLOOR_MAP.md              Semantic floor map (5 floors, TTL derivation)
+├── REJECTED_C32_CANDIDATE_SYNTHESIS.md    C.32 rejection (activation bias)
+└── REJECTED_NQD_OEE_CULTURAL_EVOLUTION.md NQD/OEE rejection (bias injector)
+```
+
+## Relationship to ailev/FPF
+
+This package is built on [ailev/FPF](https://github.com/ailev/FPF) by Anatoly Levenchuk. It is an independent implementation — our own research and code, MIT-licensed, with further development rights.
+
+### What we reviewed
+
+We cross-checked the following FPF commits (June 2026 precision restoration cluster) against our code:
+
+- [`20c8a0a`](https://github.com/ailev/FPF/commit/20c8a0a) — ontic, declarative algorithms, method-work cleanup
+- [`205de76`](https://github.com/ailev/FPF/commit/205de76) — role and method ontic refactoring
+- [`cf12b97`](https://github.com/ailev/FPF/commit/cf12b97) — U-kinds+ontics normalization
+- [`fe0df9d`](https://github.com/ailev/FPF/commit/fe0df9d) — holons and meta-holon transition normalization
+- [`3becd8e`](https://github.com/ailev/FPF/commit/3becd8e) — MOVE precision restoration
+- [`b74ecf2`](https://github.com/ailev/FPF/commit/b74ecf2) — move disambiguation full corpus scan
+
+**Verdict**: the FPF precision restoration confirms our existing design choices rather than contradicting them. His semantics got closer to what we already built.
+
+### What we adopted
+
+One item passed our scope filter:
+
+- **A.15.5 Work-Entry Readiness** — "is everything ready to even start this work?" is a different question from "does the gate pass?" Added as `readiness_refs` on transitions, enforced as a guard condition. Thin enough to be a guard, not a new primitive.
+
+### What we rejected
+
+Two FPF pattern families rejected for activation bias — they amplify existing LLM priors instead of constraining them:
+
+- **C.32 Candidate-Synthesis Logic** ([`10cd224`](https://github.com/ailev/FPF/commit/10cd224cef9c92043fb6821e165decd6ea05073f)) — variant racing, tradeoff-seeking, candidate-multiplying. These are motion patterns, not neutral semantic relations. See [REJECTED_C32_CANDIDATE_SYNTHESIS.md](fpf_thinking_map/REJECTED_C32_CANDIDATE_SYNTHESIS.md).
+- **NQD/OEE/Cultural Evolution** (C.17–C.19, A.4) — novelty-seeking, diversity-maintaining, search-front expanding. Same activation bias class. See [REJECTED_NQD_OEE_CULTURAL_EVOLUTION.md](fpf_thinking_map/REJECTED_NQD_OEE_CULTURAL_EVOLUTION.md).
+
+**Design rule**: the map evaluates and constrains moves. It does not propose them. Generative, branch-friendly, candidate-multiplying patterns are the opposite of what a per-move guard-constrained thinking map should contain.
+
+## Sources
+
+- **[FPF (First Principles Framework)](https://github.com/ailev/FPF)** by Anatoly Levenchuk — transdisciplinary specification (~51k lines). We extracted 10 semantic primitives and 9 guard rules. This is a compiled distillation, not a port.
+- **Computational logic (Mitev L.)** — "Bazele programarii logice." 6 propositional logic operators and the Wumpus World agent navigation pattern.
+
+Full attribution in [SOURCES.md](fpf_thinking_map/SOURCES.md).
+
+## Why v1.1 exists — reasoning about reasoning is the bug
+
+When an LLM navigates a multi-step decision, it faces the same sub-questions at every step: "Is my evidence still valid? Am I going in circles? Is there another path? Why am I blocked?" Without structure, the model re-derives these answers from scratch each time — re-reasoning on its own prior reasoning. Each pass costs tokens, drifts from the original question, and eventually the context fills up with the model arguing with itself about whether it already checked something it checked three steps ago.
+
+This is not a hypothetical failure mode. It is the default behavior of every frontier model on multi-step tasks. The model loops, the reasoning amplifies, the token budget runs out, and the final output is whatever the model managed to squeeze out before the window closed. The answer is technically "an answer" in the same way that a student who ran out of exam time scribbles something in the last 30 seconds.
+
+**v1.1 replaces re-reasoning with arithmetic.** Instead of asking the model "is this evidence still good?" on every step, the code counts hops and computes freshness from a trust formula. Instead of asking "am I stuck or done?", the engine checks transitions, bridges, and actions — and returns a discrete outcome (IDLE, BRIDGE, COLLECT_EVIDENCE). Instead of hiding "why can't I proceed?" behind a boolean, the slice spells out the blockers in plain text.
+
+The model's job shrinks from "figure out the entire epistemic state of your own reasoning" to "read this small JSON, pick the next move." The thinking map handles what the model is bad at (tracking state across steps) and leaves it what it is good at (interpreting context and choosing between options).
+
+## v1.2.1 changes
+
+- **TTL evidence decay** — evidence degrades CURRENT → STALE → EXPIRED as traversal steps accumulate. The rate is computed from the FGR trust tuple: formal evidence from reliable sources lasts longer, anecdotal evidence expires fast. No more static evidence that stays green forever across a 10-step traversal. See [FPF_FLOOR_MAP.md](fpf_thinking_map/FPF_FLOOR_MAP.md) for the 5-floor vertical map.
+- **EvidenceFresh proposition** — `EvidenceFresh("test_results")` returns False when evidence has TTL-decayed. The deploy readiness rule now uses this instead of raw presence checks. The logic layer uses math, not re-reasoning, to decide if evidence is still valid.
+- **IDLE outcome** — distinguishes "at rest, nothing actionable" from "stuck, need input." When the map is done, it says so — the model does not loop trying to find work that does not exist.
+- **Bridge traversal** — when dead-ended in a context, the engine checks precomputed bridge targets. If a bridge leads to a context with transitions, the agent gets a concrete cross-context escape with target info, entry states, and translation loss. No more dead ends that the model tries to reason its way out of.
+- **Slice blockers** — `slice()` now explains *why* a move cannot fire: which gate abstained, which evidence is missing, which guard denied. The operator sees the problem, not just a red light.
+- **Evidence status in prompt** — the LLM prompt state now includes per-evidence freshness and TTL remaining. The model sees "test_results: 3 steps left" instead of just "test_results: exists." Decisions informed by countdown, not by guessing.
+- **Response contract** — every slice now ends with a `response_contract`: the structured template the model must fill when responding. Pre-filled fields (scope, basis with freshness/TTL, allowed use, not allowed use, modality, canonical terms, audience) come from the computed state. Empty fields (claim, risky aliases) are for the model. This is why all the code exists — so the contract has precomputed, validated values instead of being re-derived by the model from scratch.
+
+## Design principles
+
+- **Only add structure when it changes agentic behavior** — not for source fidelity alone
+- **Per-step chew = one move slice** — never context feast
+- **Horizontal operational clarity** over vertical semantic completeness
+- **Compile-time richness** over runtime payload growth
+
+## Using as a dependency
+
+This package is the reasoning engine. Your domain maps run on top of it.
+
+```bash
+pip install git+https://github.com/igareosh/prichindel.com-agentic-thinking-map.git
+```
+
+```python
+from fpf_thinking_map import (
+    SemanticMap, ContextPrimitive, RolePrimitive, TransitionPrimitive,
+    GatePrimitive, GateCheck, EvidencePrimitive, CommitmentPrimitive,
+    FGR, Freshness, SemanticFloor, DeonticModality, AgencyLevel,
+    RuntimeBinding, ThinkingMapTraversal,
+    LogicLayer, DecisionRule, RuleKind, EvidenceFresh,
+)
+
+# 1. Build your domain map
+sm = SemanticMap()
+sm.register_context(ContextPrimitive("sales", "Sales Process",
+    glossary={"lead": "potential customer", "deal": "qualified opportunity"},
+    invariants=["no invoice without signed contract"],
+))
+sm.register_role(RolePrimitive("sales_rep", "Sales Rep", "sales",
+    incompatible_with=["approver"],
+))
+sm.register_gate(GatePrimitive("deal_gate", "Deal Gate", "sales", checks=[
+    GateCheck("contract", "Signed contract", required_evidence=["signed_contract"]),
+]))
+sm.register_transition(TransitionPrimitive(
+    "qualify", "Qualify Lead", "sales", "new_lead", "qualified",
+    required_evidence=["contact_info"],
+))
+
+# 2. Build your logic rules (optional)
+logic = LogicLayer()
+logic.add_rule(DecisionRule(
+    name="deal_ready",
+    condition=EvidenceFresh("signed_contract"),
+    action_if_true="proceed", action_if_false="collect_signature",
+    kind=RuleKind.ROUTE, tags=["sales"],
+))
+
+# 3. Create engine and step
+engine = ThinkingMapTraversal(sm, logic_layer=logic)
+state = engine.build_active_state(
+    RuntimeBinding(task="qualify lead", actor_role_ids=["sales_rep"],
+                   active_context_id="sales", current_evidence=["contact_info"]),
+    current_state="new_lead",
+)
+outcome = engine.step(state)
+# outcome.kind → CONTINUE, COLLECT_EVIDENCE, IDLE, BRIDGE, ...
+# outcome.llm_prompt_state → JSON for the model (includes response_contract)
+```
+
+The engine has no domain-specific code. The deploy example in `examples.py` is a reference implementation — your domain maps import the engine and build their own SemanticMaps, gates, and rules.
+
+## Compatibility
+
+Built with Claude Code (Anthropic claude-sonnet-4-6). Tested and verified to work with:
+
+| Model family | Status | Notes |
+|-------------|--------|-------|
+| **Anthropic Claude** (Sonnet, Opus, Haiku) | Works | Built and tested here. Slice size fits comfortably in context. |
+| **OpenAI GPT** (GPT-4o, o1, o3) | Works | Used for the 50-item source-to-code relation audit. Reads the primitives, logic rules, and prompt state correctly. |
+| **Any model that reads JSON and follows structured constraints** | Should work | The package outputs plain dicts. No model-specific prompting. |
+
+This is not a compliance seal. It means: we used these models against this package and they produced correct, usable results. The per-move slice is small enough for mid-tier models. The logic and guard outputs are plain JSON — no special tokenization or prompt format required.
+
+## License
+
+MIT. See [LICENSE](LICENSE).
+
+---
+
+**prichindel.com** — v1.2.1 — 2026-06-26

fpf_thinking_map-1.2.1/README.md

@@ -0,0 +1,189 @@
+# prichindel.com Agentic Thinking Map
+
+**v1.2.1** — [FPF (First Principles Framework)](https://github.com/ailev/FPF) compiled into a semi-formal thinking map for agentic AI guidance.
+
+A Python package that gives an AI model a small, structured board to reason on — one move at a time. Instead of freeform text generation, the model navigates a pre-shaped semantic field with deterministic guards and propositional logic constraints.
+
+**[Visual architecture →](ARCHITECTURE.md)** — module graph, step flowchart, floor map, evidence lifecycle, slice structure, deploy sequence diagram.
+
+## What it does
+
+You define a domain as a semantic map (contexts, roles, gates, evidence, transitions). The model gets a per-move slice — just the current transition, its gate, its evidence, and whether it can fire. Deterministic guards enforce hard constraints the model cannot override. Propositional logic rules (NOT, AND, OR, XOR, IMPLIES, IFF) provide decision glue between the semantic primitives and the model's reasoning.
+
+The model's job is not "what does FPF mean?" — it is: **given this semantic map and this state, what is the best lawful next move?**
+
+## Quick start
+
+```bash
+# No dependencies. Python 3.12+.
+
+# Verify the package (18 checks)
+python -m fpf_thinking_map.verify
+
+# Run the deploy decision scenario
+python -m fpf_thinking_map.examples
+```
+
+## Package contents
+
+```
+fpf_thinking_map/
+├── primitives.py             10 semantic objects from FPF spec
+├── state.py                  SemanticMap + RuntimeBinding + ActiveState + slice()
+├── guards.py                 9 deterministic guards (context, role, gate, evidence, assignment, speech act, readiness)
+├── logic.py                  6 logic operators + decision rules + LogicLayer
+├── traversal.py              Step engine with 10 lawful outcomes (incl. IDLE, BRIDGE)
+├── verify.py                 Self-verification harness (19/19 checks)
+├── examples.py               5 deploy decision scenarios (missing evidence, role conflict, logic glue, truth table)
+├── README.md                 Full documentation (any-model readable)
+├── SOURCES.md                Source attribution (FPF spec + Mitev lectures)
+├── FPF_SOURCE_TO_CODE_RELATION_AUDIT.md   50-item relation audit
+├── FPF_AUDIT_RESPONSE.md     Audit response with design decisions
+├── WHY_THIS_EXISTS.md            Compiled FPF vs raw FPF — the triple tax problem
+├── FPF_FLOOR_MAP.md              Semantic floor map (5 floors, TTL derivation)
+├── REJECTED_C32_CANDIDATE_SYNTHESIS.md    C.32 rejection (activation bias)
+└── REJECTED_NQD_OEE_CULTURAL_EVOLUTION.md NQD/OEE rejection (bias injector)
+```
+
+## Relationship to ailev/FPF
+
+This package is built on [ailev/FPF](https://github.com/ailev/FPF) by Anatoly Levenchuk. It is an independent implementation — our own research and code, MIT-licensed, with further development rights.
+
+### What we reviewed
+
+We cross-checked the following FPF commits (June 2026 precision restoration cluster) against our code:
+
+- [`20c8a0a`](https://github.com/ailev/FPF/commit/20c8a0a) — ontic, declarative algorithms, method-work cleanup
+- [`205de76`](https://github.com/ailev/FPF/commit/205de76) — role and method ontic refactoring
+- [`cf12b97`](https://github.com/ailev/FPF/commit/cf12b97) — U-kinds+ontics normalization
+- [`fe0df9d`](https://github.com/ailev/FPF/commit/fe0df9d) — holons and meta-holon transition normalization
+- [`3becd8e`](https://github.com/ailev/FPF/commit/3becd8e) — MOVE precision restoration
+- [`b74ecf2`](https://github.com/ailev/FPF/commit/b74ecf2) — move disambiguation full corpus scan
+
+**Verdict**: the FPF precision restoration confirms our existing design choices rather than contradicting them. His semantics got closer to what we already built.
+
+### What we adopted
+
+One item passed our scope filter:
+
+- **A.15.5 Work-Entry Readiness** — "is everything ready to even start this work?" is a different question from "does the gate pass?" Added as `readiness_refs` on transitions, enforced as a guard condition. Thin enough to be a guard, not a new primitive.
+
+### What we rejected
+
+Two FPF pattern families rejected for activation bias — they amplify existing LLM priors instead of constraining them:
+
+- **C.32 Candidate-Synthesis Logic** ([`10cd224`](https://github.com/ailev/FPF/commit/10cd224cef9c92043fb6821e165decd6ea05073f)) — variant racing, tradeoff-seeking, candidate-multiplying. These are motion patterns, not neutral semantic relations. See [REJECTED_C32_CANDIDATE_SYNTHESIS.md](fpf_thinking_map/REJECTED_C32_CANDIDATE_SYNTHESIS.md).
+- **NQD/OEE/Cultural Evolution** (C.17–C.19, A.4) — novelty-seeking, diversity-maintaining, search-front expanding. Same activation bias class. See [REJECTED_NQD_OEE_CULTURAL_EVOLUTION.md](fpf_thinking_map/REJECTED_NQD_OEE_CULTURAL_EVOLUTION.md).
+
+**Design rule**: the map evaluates and constrains moves. It does not propose them. Generative, branch-friendly, candidate-multiplying patterns are the opposite of what a per-move guard-constrained thinking map should contain.
+
+## Sources
+
+- **[FPF (First Principles Framework)](https://github.com/ailev/FPF)** by Anatoly Levenchuk — transdisciplinary specification (~51k lines). We extracted 10 semantic primitives and 9 guard rules. This is a compiled distillation, not a port.
+- **Computational logic (Mitev L.)** — "Bazele programarii logice." 6 propositional logic operators and the Wumpus World agent navigation pattern.
+
+Full attribution in [SOURCES.md](fpf_thinking_map/SOURCES.md).
+
+## Why v1.1 exists — reasoning about reasoning is the bug
+
+When an LLM navigates a multi-step decision, it faces the same sub-questions at every step: "Is my evidence still valid? Am I going in circles? Is there another path? Why am I blocked?" Without structure, the model re-derives these answers from scratch each time — re-reasoning on its own prior reasoning. Each pass costs tokens, drifts from the original question, and eventually the context fills up with the model arguing with itself about whether it already checked something it checked three steps ago.
+
+This is not a hypothetical failure mode. It is the default behavior of every frontier model on multi-step tasks. The model loops, the reasoning amplifies, the token budget runs out, and the final output is whatever the model managed to squeeze out before the window closed. The answer is technically "an answer" in the same way that a student who ran out of exam time scribbles something in the last 30 seconds.
+
+**v1.1 replaces re-reasoning with arithmetic.** Instead of asking the model "is this evidence still good?" on every step, the code counts hops and computes freshness from a trust formula. Instead of asking "am I stuck or done?", the engine checks transitions, bridges, and actions — and returns a discrete outcome (IDLE, BRIDGE, COLLECT_EVIDENCE). Instead of hiding "why can't I proceed?" behind a boolean, the slice spells out the blockers in plain text.
+
+The model's job shrinks from "figure out the entire epistemic state of your own reasoning" to "read this small JSON, pick the next move." The thinking map handles what the model is bad at (tracking state across steps) and leaves it what it is good at (interpreting context and choosing between options).
+
+## v1.2.1 changes
+
+- **TTL evidence decay** — evidence degrades CURRENT → STALE → EXPIRED as traversal steps accumulate. The rate is computed from the FGR trust tuple: formal evidence from reliable sources lasts longer, anecdotal evidence expires fast. No more static evidence that stays green forever across a 10-step traversal. See [FPF_FLOOR_MAP.md](fpf_thinking_map/FPF_FLOOR_MAP.md) for the 5-floor vertical map.
+- **EvidenceFresh proposition** — `EvidenceFresh("test_results")` returns False when evidence has TTL-decayed. The deploy readiness rule now uses this instead of raw presence checks. The logic layer uses math, not re-reasoning, to decide if evidence is still valid.
+- **IDLE outcome** — distinguishes "at rest, nothing actionable" from "stuck, need input." When the map is done, it says so — the model does not loop trying to find work that does not exist.
+- **Bridge traversal** — when dead-ended in a context, the engine checks precomputed bridge targets. If a bridge leads to a context with transitions, the agent gets a concrete cross-context escape with target info, entry states, and translation loss. No more dead ends that the model tries to reason its way out of.
+- **Slice blockers** — `slice()` now explains *why* a move cannot fire: which gate abstained, which evidence is missing, which guard denied. The operator sees the problem, not just a red light.
+- **Evidence status in prompt** — the LLM prompt state now includes per-evidence freshness and TTL remaining. The model sees "test_results: 3 steps left" instead of just "test_results: exists." Decisions informed by countdown, not by guessing.
+- **Response contract** — every slice now ends with a `response_contract`: the structured template the model must fill when responding. Pre-filled fields (scope, basis with freshness/TTL, allowed use, not allowed use, modality, canonical terms, audience) come from the computed state. Empty fields (claim, risky aliases) are for the model. This is why all the code exists — so the contract has precomputed, validated values instead of being re-derived by the model from scratch.
+
+## Design principles
+
+- **Only add structure when it changes agentic behavior** — not for source fidelity alone
+- **Per-step chew = one move slice** — never context feast
+- **Horizontal operational clarity** over vertical semantic completeness
+- **Compile-time richness** over runtime payload growth
+
+## Using as a dependency
+
+This package is the reasoning engine. Your domain maps run on top of it.
+
+```bash
+pip install git+https://github.com/igareosh/prichindel.com-agentic-thinking-map.git
+```
+
+```python
+from fpf_thinking_map import (
+    SemanticMap, ContextPrimitive, RolePrimitive, TransitionPrimitive,
+    GatePrimitive, GateCheck, EvidencePrimitive, CommitmentPrimitive,
+    FGR, Freshness, SemanticFloor, DeonticModality, AgencyLevel,
+    RuntimeBinding, ThinkingMapTraversal,
+    LogicLayer, DecisionRule, RuleKind, EvidenceFresh,
+)
+
+# 1. Build your domain map
+sm = SemanticMap()
+sm.register_context(ContextPrimitive("sales", "Sales Process",
+    glossary={"lead": "potential customer", "deal": "qualified opportunity"},
+    invariants=["no invoice without signed contract"],
+))
+sm.register_role(RolePrimitive("sales_rep", "Sales Rep", "sales",
+    incompatible_with=["approver"],
+))
+sm.register_gate(GatePrimitive("deal_gate", "Deal Gate", "sales", checks=[
+    GateCheck("contract", "Signed contract", required_evidence=["signed_contract"]),
+]))
+sm.register_transition(TransitionPrimitive(
+    "qualify", "Qualify Lead", "sales", "new_lead", "qualified",
+    required_evidence=["contact_info"],
+))
+
+# 2. Build your logic rules (optional)
+logic = LogicLayer()
+logic.add_rule(DecisionRule(
+    name="deal_ready",
+    condition=EvidenceFresh("signed_contract"),
+    action_if_true="proceed", action_if_false="collect_signature",
+    kind=RuleKind.ROUTE, tags=["sales"],
+))
+
+# 3. Create engine and step
+engine = ThinkingMapTraversal(sm, logic_layer=logic)
+state = engine.build_active_state(
+    RuntimeBinding(task="qualify lead", actor_role_ids=["sales_rep"],
+                   active_context_id="sales", current_evidence=["contact_info"]),
+    current_state="new_lead",
+)
+outcome = engine.step(state)
+# outcome.kind → CONTINUE, COLLECT_EVIDENCE, IDLE, BRIDGE, ...
+# outcome.llm_prompt_state → JSON for the model (includes response_contract)
+```
+
+The engine has no domain-specific code. The deploy example in `examples.py` is a reference implementation — your domain maps import the engine and build their own SemanticMaps, gates, and rules.
+
+## Compatibility
+
+Built with Claude Code (Anthropic claude-sonnet-4-6). Tested and verified to work with:
+
+| Model family | Status | Notes |
+|-------------|--------|-------|
+| **Anthropic Claude** (Sonnet, Opus, Haiku) | Works | Built and tested here. Slice size fits comfortably in context. |
+| **OpenAI GPT** (GPT-4o, o1, o3) | Works | Used for the 50-item source-to-code relation audit. Reads the primitives, logic rules, and prompt state correctly. |
+| **Any model that reads JSON and follows structured constraints** | Should work | The package outputs plain dicts. No model-specific prompting. |
+
+This is not a compliance seal. It means: we used these models against this package and they produced correct, usable results. The per-move slice is small enough for mid-tier models. The logic and guard outputs are plain JSON — no special tokenization or prompt format required.
+
+## License
+
+MIT. See [LICENSE](LICENSE).
+
+---
+
+**prichindel.com** — v1.2.1 — 2026-06-26

fpf_thinking_map-1.2.1/fpf_thinking_map/FPF_AUDIT_RESPONSE.md

@@ -0,0 +1,88 @@
+# FPF Source-to-Code Relation Audit — Response
+
+Reviewer: prichindel.com
+Date: 2026-06-24
+Input: `FPF_SOURCE_TO_CODE_RELATION_AUDIT.md` (50 items)
+
+## Summary verdict
+
+The audit is accurate. All 50 items are real findings — no false positives. The question is which ones to fix, which to accept as intentional compression, and which to defer.
+
+The guiding principle: **this package is a compiled thinking map, not a FPF reimplementation**. We extracted 8 objects from a 51k-line spec. Every compression was a conscious trade: less fidelity to the source, more usability for a mid-tier model chewing a per-move slice.
+
+The audit correctly identifies where compression crossed into **wrong-shape** (we said something the spec forbids) vs **missing** (we left something out). Wrong-shape must be fixed. Missing is a judgment call.
+
+---
+
+## Category 1: Fix now (wrong-shape or high-value missing, no runtime bloat)
+
+These items either violate the source spec in a way that produces incorrect behavior, or are cheap to fix without widening the per-step chew.
+
+| ID | What | Why fix | How |
+|----|------|---------|-----|
+| **R02** | `parent_context_id` encodes forbidden context containment | The FPF spec explicitly says "contexts do not form holarchies with each other." Our field contradicts this. | **Remove `parent_context_id` from `ContextPrimitive`.** Cross-context relation goes through bridges only. |
+| **R40** | Gate lattice missing `BLOCK`; `ABSTAIN` overloaded as both "insufficient info" and "hard denial" | Source gate lattice is `abstain ≤ pass ≤ degrade ≤ block`. Our `ABSTAIN` conflates two distinct outcomes. | **Add `GateDecision.BLOCK` to the enum.** `ABSTAIN` = insufficient evidence (can be resolved). `BLOCK` = hard denial (cannot proceed). Update gate evaluation and guards. |
+| **R30** | `WorkPrimitive(kind=PLAN)` compresses `WorkPlan` into `Work` | Source explicitly separates `U.Work` (occurrence) from `U.WorkPlan` (intent). Our `WorkKind` enum masks a real type distinction. | **Split into `WorkPrimitive` (enactment only) and `WorkPlanPrimitive` (planning only).** Drop `WorkKind` enum — the type IS the distinction. |
+| **R05** | Context invariants stored but never enforced | Invariants are strings that nothing reads. They exist in the prompt state but are not checked by guards or logic. | **Add invariant-check guard** that evaluates invariant expressions against the current state. Even if invariants stay semi-formal (strings the LLM evaluates), they should at least appear in the guard/logic path, not just in the glossary dump. |
+
+## Category 2: Fix next round (genuine gaps, but require design thought)
+
+These items are real structural absences. Fixing them adds value but requires deciding on shape. Queue for next pass.
+
+| ID | What | Why next round | Shape sketch |
+|----|------|---------------|-------------|
+| **R07/R08** | No first-class `RoleAssignment` — roles bound directly via runtime IDs | The audit is right: FPF has `U.RoleAssignment` as a distinct object that binds holder to role inside a context with a time window. Our `actor_role_ids` is a shortcut. | Add `RoleAssignment` dataclass with `holder_id`, `role_id`, `context_id`, `window`. `RuntimeBinding` references assignments, not raw role IDs. `active_roles` resolves from assignments. |
+| **R09** | No `RoleEnactment` — work doesn't reference the assignment it was performed under | Source says `RoleEnactment ::= <work, by: RoleAssignment>`. Our `WorkPrimitive.actor_role_id` is a loose string, not a reference to an assignment. | When R07/R08 land, add `performed_under: str` (assignment ID) to `WorkPrimitive`. |
+| **R17** | `CommitmentPrimitive` lacks `subject`, `referents`, `owed_to`, `source` | Source commitment is richer: accountable subject, who it's owed to, what it refers to, where it came from. Our version only has modality + evidence refs. | Add fields. These don't widen per-step chew because commitments are only consulted when explicitly in scope. |
+| **R20/R21** | No speech-act structure for communicative work | Source has `U.SpeechAct` as a `U.Work` subtype for approvals, authorizations, revocations. We have no way to model "approval as a communicative act that institutes a commitment." | Add `SpeechActPrimitive` as a `WorkPrimitive` subtype with `act_types`, `addressed_to`, `institutes`. Only enters the path when the current move is communicative. |
+| **R32** | `WorkPrimitive` lacks `primary_target` and source-aligned work kinds | Source distinguishes Operational / Communicative / Epistemic work kinds and requires a primary target. | Add `work_kind` (operational/communicative/epistemic) and `primary_target` fields. |
+| **R24/R25** | Evidence is flat — no typed DAG, no `verifiedBy` vs `validatedBy` distinction | Source evidence graph has typed nodes, edges, and a formal-vs-empirical anchor split. Ours is `supports: list[str]`. | Add `EvidenceEdge` dataclass with `kind` (supports/contradicts/verifies/validates) and build a minimal graph. Keep the evidence primitive itself flat; the graph is a separate structure on `SemanticMap`. |
+
+## Category 3: Accept as intentional compression (do not fix)
+
+These items are correctly identified as missing, but adding them would turn the thinking map into a FPF reimplementation. The compression is the feature.
+
+| IDs | What | Why keep compressed |
+|-----|------|-------------------|
+| **R01** | `ContextPrimitive` is not a `U.Holon` with a `U.Boundary` | The holonic foundation is FPF's deepest abstraction layer. We don't need Entity → Holon → System/Episteme for a thinking map. Context-as-bounded-frame is sufficient. |
+| **R03** | Roles not structurally attached to context object | Roles are indexed by `context_id` globally, and `active_roles` validates context match at runtime. Attaching a role registry directly to the context object would duplicate the `SemanticMap.roles` dict. The runtime behavior is correct. |
+| **R04** | Bridge lacks `fit/congruence` field | `translation_loss` is sufficient for the current use case. Adding a formal congruence level adds semantic weight without operational benefit in the thinking map. |
+| **R06** | No bridge-mediated term translation path | Bridge-aware term lookup is a RAG/retrieval feature, not a thinking map feature. The map tells the LLM that a bridge exists and what the loss is; the LLM does the translation. |
+| **R10/R11** | No holder-kind eligibility model | FPF's distinction between System holders (behavioral roles) and Episteme holders (status roles) is deep ontology. The thinking map doesn't need to type-check holders; it needs to check role conflicts and context scope. |
+| **R12** | No assignment window / time discipline | Time windows are important in FPF for formal role lifecycle. In the thinking map, temporal validity is handled by evidence freshness and external constraints, not by role assignment windows. |
+| **R13** | Authoritative vs observational role assignments | This distinction matters in formal FPF gate semantics. In the thinking map, the guard layer handles gate authority via the gate-transition binding, not via role assignment modes. |
+| **R14** | `specializes` pointer not used for `requiredRoles` substitution | Role substitution is FPF's formal role algebra. The thinking map checks conflict (⊥) which is the operationally critical case. Specialization substitution is a vertical enrichment. |
+| **R15** | Conflict checked as simultaneous IDs, not overlapping assignment windows | Same as R12 — window discipline is deferred. ID-based conflict check catches the operational case. |
+| **R16** | No bundle operator (⊗) | Role bundles are formal role algebra. The thinking map supports multi-role binding via `actor_role_ids` and checks conflicts. Bundles add formalism without operational payoff at this level. |
+| **R18** | Commitment checks reduce to evidence completion | Source wants accountable subject distinct from evidence. For the thinking map, evidence-backed commitment is the operational check. Subject accountability is a governance layer concern. |
+| **R19** | No commitment conflict channel | The logic layer's `exclusive_with` handles action contradictions. Formal commitment-level conflict requires the richer commitment model from R17. |
+| **R22** | No "institutes/updates/revokes" relation | This is the speech-act machinery from R20/R21. Deferred to that implementation. |
+| **R23** | Publication is "just a face record" | Intentional. Publication is out of the step path. Adding projection lineage turns it into a rendering engine. |
+| **R26** | No symbol carrier register (SCR/RSCR) | Deep FPF publication machinery. Not needed for a thinking map. |
+| **R27** | No scope separation between design-time and run-time evidence | Good formal discipline, but the thinking map's evidence is always runtime (current_evidence). Design-time evidence doesn't enter the per-step path. |
+| **R28** | No external-transformer relation for evidence production | Important in FPF for audit trails. The thinking map trusts evidence IDs as given by the binding. Externality is a governance concern. |
+| **R29** | No ordered trace or method instantiation card | `method_id` is a loose pointer. For the thinking map, this is sufficient — the model doesn't need to reconstruct method instantiation chains per step. |
+| **R31/R33** | Work lacks `performedBy`, `isExecutionOf` as first-class links | These are source canonical relations. The thinking map uses loose IDs (`method_id`, `actor_role_id`). First-class links would be the right shape after R07/R08/R09 land. |
+| **R34** | `method_id` collapses method and method-description | FPF's Method/MethodDescription distinction. For the thinking map, a method reference is enough. |
+| **R35** | No capability primitive | `U.Capability` is a system attribute in FPF. The thinking map checks role eligibility and gate passage, not capability declarations. |
+| **R36** | Work lacks occurrence window, resource ledger, acceptance outcome | Full work record semantics. The thinking map tracks inputs/outputs and evidence refs. Detailed occurrence tracking is an execution engine concern. |
+| **R37** | No work acceptance against spec-standard chain | CAC (Context-Assignment-Standard) checks are formal FPF acceptance. The thinking map's guards cover context and evidence, not spec-standard chains. |
+| **R38** | `WorkPlan` lacks dependencies, budgets, variance dimensions | Full planning semantics. Deferred to R30 split, but detailed planning fields are execution-engine scope. |
+| **R39** | No `plannedAs` / fulfilment / variance relation | Depends on R30 (WorkPlan split). Deferred. |
+| **R41/R42/R43/R44** | Gate model lacks profiles, CV/GF split, decision logs, fold policies | Deep gate semantics. The thinking map's gate model (checks → tri-state → decision) covers the operational case. Profile-bound folds and decision logs are audit-trail features. |
+| **R45/R46/R47/R48/R49** | Publication lacks viewpoints, pin discipline, comparator sets, publication-scope | Deep MVPK semantics. Publication is intentionally thin in the thinking map — it's a face label, not a rendering engine. |
+| **R50** | Slice-first runtime is built from compressed primitives | Correct observation. This is the design: compressed primitives → small slices → usable per-step chew. Enriching primitives is the next pass (Category 2), but only fields that don't widen the slice. |
+
+---
+
+## Scorecard
+
+| Category | Count | Action |
+|----------|-------|--------|
+| Fix now (wrong-shape or cheap high-value) | 4 items (R02, R05, R30, R40) | Implement this round |
+| Fix next round (genuine gaps, need design) | 6 items (R07/R08, R09, R17, R20/R21, R24/R25, R32) | Queue with shape sketches |
+| Intentional compression (keep as-is) | 40 items | Document as design decisions |
+
+---
+
+prichindel.com | 2026-06-24 | v1.0.0