REFERENCE

Implementation reference

Entry points, outcome vocabulary, and primary integration documents.

The context block — runs anywhere

This is the block that matters if you just want to use the library, not test it. It does not need Claude Code, MCP, or an account — it works in any Python process: your own agent, a notebook, a CI job, or pasted straight into a chat session so you can set the context in one shot. Adapted directly from the package README:

pip install fpf-thinking-map

from fpf_thinking_map.state import SemanticMap, RuntimeBinding
from fpf_thinking_map.primitives import (
    ContextPrimitive, RolePrimitive, GatePrimitive, GateCheck, TransitionPrimitive,
)
from fpf_thinking_map.logic import LogicLayer, DecisionRule, RuleKind, EvidencePresent, GatePasses
from fpf_thinking_map.traversal import ThinkingMapTraversal

# 1. your domain: contexts, roles, gates, transitions
sm = SemanticMap()
sm.register_context(ContextPrimitive("my_domain", "My Domain",
    glossary={"review": "check code for correctness"}))
sm.register_role(RolePrimitive("reviewer", "Reviewer", "my_domain"))
sm.register_gate(GatePrimitive("review_gate", "Review Gate", "my_domain", checks=[
    GateCheck("tests", "Tests must pass", required_evidence=["test_results"]),
]))
sm.register_transition(TransitionPrimitive(
    "start_to_reviewed", "Start -> Reviewed", "my_domain",
    from_state="start", to_state="reviewed",
    required_gate_id="review_gate", required_evidence=["test_results"],
))

# 2. optional: your own logic rules
logic = LogicLayer()
logic.add_rule(DecisionRule(
    name="review_ready",
    condition=EvidencePresent("test_results").AND(GatePasses("review_gate")),
    action_if_true="proceed_to_review", action_if_false="not_ready",
    kind=RuleKind.ROUTE, tags=["review"],
))

# 3. the engine, one step
engine = ThinkingMapTraversal(sm, logic_layer=logic)
binding = RuntimeBinding(
    task="review PR #42", actor_role_ids=["reviewer"],
    active_context_id="my_domain", current_evidence=["test_results"],
)
state = engine.build_active_state(binding, current_state="start")
outcome = engine.step(state, transition_id="start_to_reviewed")
print(outcome.kind, outcome.llm_prompt_state)

Replace my_domain/reviewer/review_gate with your own context, role, and gate — the rest of the mechanism (state, slice, typed result) stays the same.

Agent prompt

Don't want to write the frame by hand? Paste the prompt below into any coding agent (Claude Code, Cursor, etc.) that already has access to your project — it builds the map from your project's real code, not the generic example above.

Integrate the fpf-thinking-map library (pip install fpf-thinking-map) into this project.

1. Look at this project's real code to find its actual states, roles, and risky transitions — do not invent a generic placeholder domain. Ask me if it isn't obvious.
2. Build a SemanticMap: a ContextPrimitive for the domain, RolePrimitive(s) for who may act, GatePrimitive/GateCheck for what evidence a risky transition requires, and TransitionPrimitive(s) for the real state moves.
3. Wire a ThinkingMapTraversal into the agent's existing loop: call step() before proposing a move, and attempt_transition()/attempt_bridge() to actually perform one. Never mutate state directly.
4. Route on outcome.kind (CONTINUE, ABSTAIN, COLLECT_EVIDENCE, CHANGE_FRAME, IDLE, BRIDGE, AWAIT, ESCALATE, REVISE_PLAN) — treat ABSTAIN/ESCALATE as hard stops, not errors to retry past.
5. Run python -m fpf_thinking_map.verify to prove the map is well-formed before wiring it into anything user-facing.
6. Do not fabricate gates, roles, or transitions that don't reflect this project's real risk surface — an unused, decorative map is worse than no map.

Reference: fpf_thinking_map/README.md in the installed package, and ARCHITECTURE.md in the repo for the full outcome/gate semantics.

Want to try it without writing code? User mode vs developer mode, in Claude Code

Six install steps, then you choose what you want to do:

1.Clone the repo — git clone https://github.com/Consolidare-Continuum/fpf-agentic-thinking-map
2.Enter the folder — cd fpf-agentic-thinking-map
3.Install locally — pip install -e .
4.Install the test server — pip install -r dev_mcp/requirements.txt
5.Verify it — python -m dev_mcp.test_server — you should see 42/42
6.Add it to Claude Code with one command — claude mcp add fpf-test -- python -m dev_mcp.server

User mode

You test your own domain conversationally. You ask Claude: “build a run_scenario with scope="user-extension" for my case, starting from the context code above” — Claude writes and runs the scenario, you see the result.

Developer mode

You audit the library itself. You ask Claude: “run get_audit_gaps with scope="core" and show me one coverage gap” — useful if you want to contribute or check limits, not learn basic usage.

Both are inspection modes, not production modes — perfect for feeling the library in 10 minutes before deciding whether it is worth integrating seriously. For production, you use the context code above directly, inside your own process.

Main objects

SemanticMap	Static structure and allowed relationships.
RuntimeBinding	Current role, state, and evidence.
ThinkingMapTraversal	Candidate selection, gates, and result.

Typed outcomes

9 live outcomes out of 11 declared — CONTINUE · ABSTAIN · COLLECT_EVIDENCE · CHANGE_FRAME · IDLE · BRIDGE · AWAIT · ESCALATE · REVISE_PLAN. Not yet wired: ASK, PUBLISH.

Repository documents

Want this in your own project?

The core is free, under the MIT license — you can take it and keep building with your own team, without needing us for that. But if you want to integrate ATM with us — as consultants or as developers, in a real agentic system: finance, e-commerce, anything where an agent has to respect a frame, not just improvise — write directly: consolidare_continuum@proton.me — the project maintainer's address, I read and reply myself, not an anonymous contact form.