fpf-thinking-map 1.2.1__tar.gz → 1.3.0__tar.gz

{fpf_thinking_map-1.2.1 → fpf_thinking_map-1.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fpf-thinking-map
-Version: 1.2.1
+Version: 1.3.0
 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
@@ -27,7 +27,7 @@ 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.
+**v1.3.0** — [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.
 
@@ -44,7 +44,7 @@ The model's job is not "what does FPF mean?" — it is: **given this semantic ma
 ```bash
 # No dependencies. Python 3.12+.
 
-# Verify the package (18 checks)
+# Verify the package (21 checks)
 python -m fpf_thinking_map.verify
 
 # Run the deploy decision scenario
@@ -60,7 +60,7 @@ fpf_thinking_map/
 ├── 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)
+├── verify.py                 Self-verification harness (21/21 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_thinking_map-1.2.1 → fpf_thinking_map-1.3.0}/README.md

@@ -1,6 +1,6 @@
 # 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.
+**v1.3.0** — [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.
 
@@ -17,7 +17,7 @@ The model's job is not "what does FPF mean?" — it is: **given this semantic ma
 ```bash
 # No dependencies. Python 3.12+.
 
-# Verify the package (18 checks)
+# Verify the package (21 checks)
 python -m fpf_thinking_map.verify
 
 # Run the deploy decision scenario
@@ -33,7 +33,7 @@ fpf_thinking_map/
 ├── 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)
+├── verify.py                 Self-verification harness (21/21 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_thinking_map-1.3.0/fpf_thinking_map/RELATED_WORK_GOFLOW_FPF_SKILL.md

@@ -0,0 +1,88 @@
+# Related work: goflowspace/goflow FPF skill
+
+**Status**: Acknowledged — independent prior art, not incorporated.
+**Date**: 2026-06-30 (discovered 2026-06-29)
+**Decision by**: igareosh (prichindel.com)
+**Related repo**: [goflowspace/goflow](https://github.com/goflowspace/goflow/tree/main/.claude/skills/fpf)
+**FPF source repo**: [ailev/FPF](https://github.com/ailev/FPF)
+
+---
+
+## What we found
+
+An independent decomposition of Levenchuk's FPF specification, published as a Claude Code skill at `goflowspace/goflow/.claude/skills/fpf/`. Both projects derive from the same source — FPF-Spec.md, ~51,000 lines — with no mutual awareness, and arrived at opposite designs.
+
+Full respect for the effort: 189 pattern files across 11 domains, roughly 3.7 MB of structured reference material, plus maintenance tooling (`fpf_tools.py`, `split_fpf_spec.py`, `audit_fpf_patterns.py`) to search and audit the corpus. It is free, public, and a serious piece of decomposition work. This note exists to record what it is, what we evaluated from it, and why none of it was pulled in here — not to diminish it.
+
+## What goflow built
+
+A **prompt-time reference library**. The model reads pattern markdown at inference time, evaluates its own position against natural-language criteria written into the patterns, and picks the next branch. Progressive disclosure (master index → domain index → pattern file) keeps token cost down. It is a skill, not an engine — there is no code that evaluates state and returns a verdict; the model is the evaluator.
+
+## What this package builds
+
+A **runtime constraint engine**: 10 primitives, 9 deterministic guards, 6 propositional logic operators, one traversal loop. The model never evaluates its own reasoning state. It receives a state snapshot, the engine checks deterministic facts (evidence present, gate passed, role conflict, freshness), and returns one of eight fixed outcomes. The model navigates a board with walls; it does not judge the quality of its own thinking.
+
+## Coverage comparison
+
+| Domain | goflow patterns | This package |
+|---|---|---|
+| foundations (A.0–A.19) | 20 | 10 primitives |
+| transformation (A.3–A.15, B.4) | 14 | WorkPrimitive, WorkPlanPrimitive |
+| reasoning (B.5–B.7) | 8 | — |
+| trust-evidence (A.10, B.3, C.2) | 12 | EvidencePrimitive + FGR |
+| aggregation (B.1–B.2) | 15 | — |
+| signature (A.6) | 17 | ContextBridge only |
+| architheories (C.1–C.25) | 46 | — |
+| constitution (E.1–E.20) | 30 | — |
+| unification (F.0–F.18) | 20 | — |
+| ethics (D.5) | 2 | — |
+| sota (G.0–G.13) | 16 | — |
+
+goflow covers roughly 5x the specification surface. That is the correct outcome for a reference library and the wrong direction for a constraint engine — see `WHY_THIS_EXISTS.md` on the compiled-vs-raw tax this package is built to avoid.
+
+## The core design disagreement
+
+goflow's skill is a prompt-time reference the model reads, self-evaluates against, and uses to steer its own reasoning. The model asks itself "am I in Explore or Shape?", answers itself, and picks the next branch. The patterns are decision trees the model walks by interpreting natural-language criteria written into the pattern text.
+
+This package is the opposite. The model does not self-evaluate. The engine evaluates state and returns a verdict; the model gets an `Outcome` it can act on. The model navigates, the guards constrain. No self-assessment, anywhere in the loop.
+
+Two valid designs for different problems. goflow trusts the model to be an honest judge of its own reasoning state. We don't.
+
+We also don't think we need to. This package has never had to put a model in the position of reasoning about its own reasoning — and reasoning-about-reasoning is exactly where models hallucinate most confidently. A model asked "what kind of thinking am I doing right now" will answer fluently and wrongly with equal ease; there is no way to check the answer against anything external. The map's job is to give the model a board to walk and walls it cannot walk through — not to ask it to grade the quality of its own thought, which is the one judgment call it cannot be trusted to make honestly.
+
+## Patterns evaluated and rejected
+
+### B.5.1 — Explore → Shape → Evidence → Operate (ESEO)
+
+Considered adding a `ReasoningPhase` enum to `ActiveState` (EXPLORE / SHAPE / EVIDENCE / OPERATE) with a guard enforcing phase order, mirroring goflow's lifecycle pattern.
+
+**Rejected.** Phase assignment requires the model to answer "am I in Explore or Shape?" — a self-evaluative claim with no externally checkable answer. A guard that validates this claim is circular: it constrains a fact only the constrained party can report. It also forks the decision into three branches before any guard runs, which is the wrong direction for a package designed to converge to one move per step (same objection as `REJECTED_NQD_OEE_CULTURAL_EVOLUTION.md`).
+
+What ESEO actually prescribes — no operating without evidence, no skipping the shaping step — is already enforced by the existing guards:
+
+- `commitment_evidence` — blocks proceeding without required evidence
+- `planning_not_enactment` — blocks marking done without work records
+- `gate_pass` — blocks skipping a structural checkpoint
+- `evidence_freshness` — flags stale evidence
+
+The lifecycle is implicit in the guard composition already shipped. Making it explicit adds an enum, a state field, a constraint, and a guard — four new moving parts to formalize something the guards already do, with no new failure mode caught.
+
+### B.5 — Canonical Reasoning Cycle (Abduction → Deduction → Induction)
+
+Considered a reasoning-mode selector mirroring the three-phase cycle.
+
+**Rejected.** Whether the model is abducting, deducing, or inducing is a property of its internal process, not of the observable state this engine evaluates (evidence, gates, transitions, roles). There is no state-layer signal to check it against. Adding the selector buys three-way ambiguity per step with no verification path — exactly the failure mode this package exists to avoid (per `WHY_THIS_EXISTS.md`).
+
+### A.3.1 / A.3.2 — Method vs. MethodDescription split
+
+goflow keeps the design-time recipe (MethodDescription) and the runtime-bound instance (Method) as separate patterns. This package's `WorkPrimitive.method_id` collapses both.
+
+**Not rejected, deferred.** Legitimate split — would add one intermediate state and one guard ("no Work without a bound Method"). Held back because no observed failure mode in current usage needs it. First candidate to revisit if method-binding bugs show up.
+
+## Conclusion
+
+Same source, opposite bets on what a model can be trusted to do with its own introspection. goflow trusts the model to grade its own reasoning state against reference text. This package doesn't, and routes every decision through external, deterministic checks instead. Nothing from goflow's decomposition was pulled into this package. The guard stack already does, implicitly, what the rejected patterns would have made explicit — without asking the model to self-report.
+
+---
+
+prichindel.com | 2026-06-30 | v1.2.1

{fpf_thinking_map-1.2.1 → fpf_thinking_map-1.3.0}/fpf_thinking_map/__init__.py

@@ -12,7 +12,7 @@ Modules:
   logic       — 6 propositional operators + freshness-aware decision rules
   traversal   — step engine with 10 lawful outcomes
   examples    — deploy decision scenarios demonstrating the full system
-  verify      — 18-check self-verification harness
+  verify      — 21-check self-verification harness
 """
 
 # --- Primitives: the semantic field ---

{fpf_thinking_map-1.2.1 → fpf_thinking_map-1.3.0}/fpf_thinking_map/state.py

@@ -170,6 +170,7 @@ class MoveTrace:
     """#24: compressed trace — last move only, no narrative accumulation."""
     previous_state: str | None = None
     last_transition_id: str | None = None
+    bridge_target: str | None = None
     blockers: list[str] = field(default_factory=list)
     evidence_delta: list[str] = field(default_factory=list)
 
@@ -339,6 +340,55 @@ class ActiveState:
         self.current_state = t.to_state
         return True
 
+    def cross_bridge(self, target_context_id: str, entry_state: str) -> tuple[bool, str]:
+        """#26: validated writeback for a cross-context bridge crossing.
+
+        FPF A.6.9 gives bridges an explicit fidelity contract — substitution_license
+        and translation_loss — but until now that contract was surfaced only as
+        advisory metadata in bridge_options(); nothing enforced it before the LLM
+        wandered into the target context. This closes that gap: the engine, not
+        the model, decides whether a crossing is licensed.
+
+        An unlicensed bridge (substitution_license=False) is fine for low/normal
+        risk moves — the translation_loss is real but tolerable. At high/critical
+        risk_level it is refused: a lossy, unlicensed substitution must not carry
+        weight it wasn't licensed for.
+
+        Returns (ok, reason). On ok=True, current_state and active_context_id are
+        updated and the crossing is recorded in trace as bridge_target.
+        """
+        ctx = self.active_context
+        if not ctx:
+            return False, "no active context to bridge from"
+
+        bridge = next(
+            (b for b in ctx.bridges_to if b.target_context_id == target_context_id),
+            None,
+        )
+        if bridge is None:
+            return False, f"no bridge from '{ctx.context_id}' to '{target_context_id}'"
+
+        if not self.semantic_map.transitions_for(target_context_id, entry_state):
+            return False, (
+                f"'{entry_state}' is not a valid entry state in '{target_context_id}' "
+                f"(no transitions start there)"
+            )
+
+        if not bridge.substitution_license and self.binding.risk_level in ("high", "critical"):
+            return False, (
+                f"bridge to '{target_context_id}' is unlicensed for substitution "
+                f"(translation_loss: '{bridge.translation_loss}') — risk_level "
+                f"'{self.binding.risk_level}' requires a licensed bridge"
+            )
+
+        self.trace = MoveTrace(
+            previous_state=self.current_state,
+            bridge_target=target_context_id,
+        )
+        self.binding.active_context_id = target_context_id
+        self.current_state = entry_state
+        return True, f"crossed to '{target_context_id}' at '{entry_state}'"
+
     def add_evidence(self, evidence_id: str) -> None:
         if evidence_id not in self.binding.current_evidence:
             self.binding.current_evidence.append(evidence_id)

{fpf_thinking_map-1.2.1 → fpf_thinking_map-1.3.0}/fpf_thinking_map/traversal.py

@@ -111,10 +111,19 @@ class ThinkingMapTraversal:
         logic_ctx: dict,
         transition_id: str | None = None,
         guard_blockers: list[str] | None = None,
+        include_full_state: bool = True,
     ) -> dict:
+        """#27: include_full_state=False ships the A-RAG "chunk read" alone.
+
+        A caller that already knows its transition_id doesn't need the whole
+        board bolted on — that's the win slice() was built for in the first
+        place. Default stays True so every existing caller sees identical
+        output; opt out only when you want the lean payload.
+        """
         if transition_id:
             prompt = state.slice(transition_id, guard_blockers=guard_blockers)
-            prompt["full_state"] = state.to_llm_prompt_state()
+            if include_full_state:
+                prompt["full_state"] = state.to_llm_prompt_state()
         else:
             prompt = state.to_llm_prompt_state()
         if logic_ctx:
@@ -131,6 +140,7 @@ class ThinkingMapTraversal:
         state: ActiveState,
         transition_id: str | None = None,
         logic_tags: set[str] | None = None,
+        include_full_state: bool = True,
     ) -> Outcome:
         """#6: one traversal step, optionally focused on a specific transition.
 
@@ -138,6 +148,9 @@ class ThinkingMapTraversal:
         Without: scans possible transitions from current state.
 
         Increments step_count each call — drives TTL evidence decay.
+
+        include_full_state=False (only meaningful together with transition_id):
+        ships the scoped slice without the full board — see #27 in _build_prompt.
         """
         state.step_count += 1
 
@@ -167,7 +180,7 @@ class ThinkingMapTraversal:
                     kind=OutcomeKind.ABSTAIN,
                     reason=f"Logic contradiction: {consistency.get('contradictions', [])}",
                     warnings=consistency.get("contradictions", []),
-                    llm_prompt_state=self._build_prompt(state, logic_ctx, transition_id),
+                    llm_prompt_state=self._build_prompt(state, logic_ctx, transition_id, include_full_state=include_full_state),
                 )
 
         allowed, guard_results = self.guard_engine.is_action_allowed(state, transition_id)
@@ -186,7 +199,8 @@ class ThinkingMapTraversal:
                     missing_evidence=missing,
                     warnings=warnings,
                     llm_prompt_state=self._build_prompt(
-                        state, logic_ctx, transition_id, guard_blockers=denials,
+                        state, logic_ctx, transition_id,
+                        guard_blockers=denials, include_full_state=include_full_state,
                     ),
                 )
             return Outcome(
@@ -208,7 +222,7 @@ class ThinkingMapTraversal:
                 reason=f"Evidence gaps: {missing}",
                 missing_evidence=missing,
                 warnings=warnings,
-                llm_prompt_state=self._build_prompt(state, logic_ctx, transition_id),
+                llm_prompt_state=self._build_prompt(state, logic_ctx, transition_id, include_full_state=include_full_state),
             )
 
         transitions = state.possible_transitions
@@ -218,7 +232,7 @@ class ThinkingMapTraversal:
                     kind=OutcomeKind.CONTINUE,
                     reason="No transitions but actions available",
                     warnings=warnings,
-                    llm_prompt_state=self._build_prompt(state, logic_ctx, transition_id),
+                    llm_prompt_state=self._build_prompt(state, logic_ctx, transition_id, include_full_state=include_full_state),
                 )
 
             bridge_opts = self.semantic_map.bridge_options(ctx_id)
@@ -240,14 +254,14 @@ class ThinkingMapTraversal:
                 kind=OutcomeKind.IDLE,
                 reason="At rest — no transitions, no actions, no bridges",
                 warnings=warnings,
-                llm_prompt_state=self._build_prompt(state, logic_ctx, transition_id),
+                llm_prompt_state=self._build_prompt(state, logic_ctx, transition_id, include_full_state=include_full_state),
             )
 
         return Outcome(
             kind=OutcomeKind.CONTINUE,
             reason="Guards pass, evidence sufficient, transitions available",
             warnings=warnings,
-            llm_prompt_state=self._build_prompt(state, logic_ctx, transition_id),
+            llm_prompt_state=self._build_prompt(state, logic_ctx, transition_id, include_full_state=include_full_state),
         )
 
     def attempt_transition(
@@ -323,6 +337,33 @@ class ThinkingMapTraversal:
             reason="Transition failed",
         )
 
+    def attempt_bridge(
+        self,
+        state: ActiveState,
+        target_context_id: str,
+        entry_state: str,
+    ) -> Outcome:
+        """#26: enact a bridge crossing the BRIDGE outcome only advertised.
+
+        step() surfaces bridge_options() as advisory metadata; this is the
+        enactment half — it enforces the bridge's fidelity contract
+        (substitution_license vs. risk_level) before mutating state, then
+        performs the crossing. An unlicensed bridge under high/critical risk
+        is refused as ESCALATE, not silently allowed.
+        """
+        ok, reason = state.cross_bridge(target_context_id, entry_state)
+        if not ok:
+            kind = OutcomeKind.ESCALATE if "unlicensed" in reason else OutcomeKind.ABSTAIN
+            return Outcome(kind=kind, reason=reason)
+
+        logic_ctx = self._eval_logic(state)
+        return Outcome(
+            kind=OutcomeKind.CONTINUE,
+            reason=reason,
+            next_state=state.current_state,
+            llm_prompt_state=self._build_prompt(state, logic_ctx),
+        )
+
     def demo_walk(
         self,
         binding: RuntimeBinding,

{fpf_thinking_map-1.2.1 → fpf_thinking_map-1.3.0}/fpf_thinking_map/verify.py

@@ -692,6 +692,96 @@ def check_bridge_outcome():
     assert o2.kind == OutcomeKind.IDLE
 
 
+def check_bridge_crossing():
+    """#26: validated writeback for bridge crossing — enact, not just advertise."""
+    def _make_map(license_: bool):
+        sm = SemanticMap()
+        sm.register_context(ContextPrimitive(
+            context_id="ctx_a", label="Context A",
+            bridges_to=[ContextBridge(
+                target_context_id="ctx_b",
+                mapping={"deploy": "release"},
+                translation_loss="ops uses 'release' where dev uses 'deploy'",
+                substitution_license=license_,
+            )],
+        ))
+        sm.register_context(ContextPrimitive(context_id="ctx_b", label="Context B"))
+        sm.register_transition(TransitionPrimitive(
+            "t_b1", "B entry", "ctx_b", "ready", "active",
+        ))
+        return sm
+
+    # Unlicensed bridge, normal risk — lossy but tolerable, crossing succeeds
+    sm = _make_map(license_=False)
+    engine = ThinkingMapTraversal(sm)
+    b = RuntimeBinding(active_context_id="ctx_a", risk_level="normal")
+    s = engine.build_active_state(b, current_state="done")
+    o = engine.attempt_bridge(s, "ctx_b", "ready")
+    assert o.kind == OutcomeKind.CONTINUE, f"Expected CONTINUE, got {o.kind}: {o.reason}"
+    assert s.binding.active_context_id == "ctx_b"
+    assert s.current_state == "ready"
+    assert s.trace.bridge_target == "ctx_b"
+
+    # Unlicensed bridge, high risk — refused, state untouched
+    sm2 = _make_map(license_=False)
+    engine2 = ThinkingMapTraversal(sm2)
+    b2 = RuntimeBinding(active_context_id="ctx_a", risk_level="high")
+    s2 = engine2.build_active_state(b2, current_state="done")
+    o2 = engine2.attempt_bridge(s2, "ctx_b", "ready")
+    assert o2.kind == OutcomeKind.ESCALATE, f"Expected ESCALATE, got {o2.kind}"
+    assert "unlicensed" in o2.reason
+    assert s2.binding.active_context_id == "ctx_a", "unlicensed+high-risk must not mutate state"
+    assert s2.current_state == "done"
+
+    # Licensed bridge, high risk — allowed despite risk level
+    sm3 = _make_map(license_=True)
+    engine3 = ThinkingMapTraversal(sm3)
+    b3 = RuntimeBinding(active_context_id="ctx_a", risk_level="high")
+    s3 = engine3.build_active_state(b3, current_state="done")
+    o3 = engine3.attempt_bridge(s3, "ctx_b", "ready")
+    assert o3.kind == OutcomeKind.CONTINUE
+    assert s3.binding.active_context_id == "ctx_b"
+
+    # No such bridge target
+    sm4 = _make_map(license_=True)
+    engine4 = ThinkingMapTraversal(sm4)
+    b4 = RuntimeBinding(active_context_id="ctx_a")
+    s4 = engine4.build_active_state(b4, current_state="done")
+    o4 = engine4.attempt_bridge(s4, "ctx_z", "ready")
+    assert o4.kind == OutcomeKind.ABSTAIN
+    assert "no bridge" in o4.reason
+
+    # Invalid entry state — not a real transition start in target context
+    sm5 = _make_map(license_=True)
+    engine5 = ThinkingMapTraversal(sm5)
+    b5 = RuntimeBinding(active_context_id="ctx_a")
+    s5 = engine5.build_active_state(b5, current_state="done")
+    o5 = engine5.attempt_bridge(s5, "ctx_b", "nowhere")
+    assert o5.kind == OutcomeKind.ABSTAIN
+    assert "not a valid entry state" in o5.reason
+
+
+def check_lean_slice():
+    """#27: include_full_state=False ships the slice without the full board."""
+    sm = SemanticMap()
+    sm.register_context(ContextPrimitive(context_id="ctx", label="Ctx"))
+    sm.register_transition(TransitionPrimitive(
+        "t1", "Do it", "ctx", "start", "done",
+    ))
+    engine = ThinkingMapTraversal(sm)
+    b = RuntimeBinding(active_context_id="ctx")
+    s = engine.build_active_state(b, current_state="start")
+
+    o_full = engine.step(s, transition_id="t1")
+    assert "full_state" in o_full.llm_prompt_state
+    assert "move" in o_full.llm_prompt_state
+
+    s2 = engine.build_active_state(b, current_state="start")
+    o_lean = engine.step(s2, transition_id="t1", include_full_state=False)
+    assert "full_state" not in o_lean.llm_prompt_state
+    assert "move" in o_lean.llm_prompt_state, "lean payload must keep the slice itself"
+
+
 def check_semantic_floors():
     """Verify semantic floor TTL computation from FGR trust factors."""
     # Floor constants exist and are correct
@@ -989,6 +1079,8 @@ def main():
         ("TTL evidence decay", check_ttl_decay),
         ("IDLE outcome", check_idle_outcome),
         ("BRIDGE outcome (cross-context)", check_bridge_outcome),
+        ("bridge crossing (validated writeback)", check_bridge_crossing),
+        ("lean slice (no full_state bolt-on)", check_lean_slice),
         ("slice blockers (HITL)", check_slice_blockers),
         ("semantic floors (FPF vertical)", check_semantic_floors),
         ("EvidenceFresh prop + integration", check_evidence_fresh_prop),

{fpf_thinking_map-1.2.1 → fpf_thinking_map-1.3.0}/fpf_thinking_map.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fpf-thinking-map
-Version: 1.2.1
+Version: 1.3.0
 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
@@ -27,7 +27,7 @@ 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.
+**v1.3.0** — [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.
 
@@ -44,7 +44,7 @@ The model's job is not "what does FPF mean?" — it is: **given this semantic ma
 ```bash
 # No dependencies. Python 3.12+.
 
-# Verify the package (18 checks)
+# Verify the package (21 checks)
 python -m fpf_thinking_map.verify
 
 # Run the deploy decision scenario
@@ -60,7 +60,7 @@ fpf_thinking_map/
 ├── 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)
+├── verify.py                 Self-verification harness (21/21 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_thinking_map-1.2.1 → fpf_thinking_map-1.3.0}/fpf_thinking_map.egg-info/SOURCES.txt

@@ -7,6 +7,7 @@ fpf_thinking_map/FPF_SOURCE_TO_CODE_RELATION_AUDIT.md
 fpf_thinking_map/README.md
 fpf_thinking_map/REJECTED_C32_CANDIDATE_SYNTHESIS.md
 fpf_thinking_map/REJECTED_NQD_OEE_CULTURAL_EVOLUTION.md
+fpf_thinking_map/RELATED_WORK_GOFLOW_FPF_SKILL.md
 fpf_thinking_map/SOURCES.md
 fpf_thinking_map/WHY_THIS_EXISTS.md
 fpf_thinking_map/__init__.py

{fpf_thinking_map-1.2.1 → fpf_thinking_map-1.3.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "fpf-thinking-map"
-version = "1.2.1"
+version = "1.3.0"
 description = "Agentic thinking map — structured reasoning constraints for LLMs with TTL evidence decay, deterministic guards, and propositional logic glue. Compiled from FPF (First Principles Framework)."
 readme = "README.md"
 license = {text = "MIT"}