Referință de implementare

Codul de context — îl rulezi oriunde

Ăsta e blocul care contează dacă vrei doar să-l folosești, nu să testezi biblioteca. Nu are nevoie de Claude Code, de MCP sau de vreun cont — merge în orice proces Python: propriul tău agent, un notebook, un job CI, sau lipit direct într-o sesiune de chat ca să dai contextul dintr-o dată. Adaptat direct din README-ul pachetului:

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)

Schimbă my_domain/reviewer/review_gate cu propriul tău context, rol și poartă — restul mecanismului (starea, felia, rezultatul tipizat) rămâne identic.

Prompt pentru agent

Nu vrei să scrii tu cadrul de mână? Lipește promptul de mai jos în orice agent de cod (Claude Code, Cursor etc.) care are deja acces la proiectul tău — construiește harta pornind de la codul real al proiectului, nu de la exemplul generic de mai sus.

Integrează biblioteca fpf-thinking-map (pip install fpf-thinking-map) în acest proiect.

1. Uită-te la codul real al proiectului ca să găsești stările, rolurile și tranzițiile riscante reale — nu inventa un domeniu generic, de umplutură. Întreabă-mă dacă nu e evident.
2. Construiește un SemanticMap: un ContextPrimitive pentru domeniu, RolePrimitive(uri) pentru cine poate acționa, GatePrimitive/GateCheck pentru ce dovezi cere o tranziție riscantă, și TransitionPrimitive(uri) pentru mișcările reale de stare.
3. Conectează un ThinkingMapTraversal în bucla existentă a agentului: apelează step() înainte de a propune o mișcare, și attempt_transition()/attempt_bridge() ca s-o și înfăptuiești. Nu modifica niciodată starea direct.
4. Rutează pe outcome.kind (CONTINUE, ABSTAIN, COLLECT_EVIDENCE, CHANGE_FRAME, IDLE, BRIDGE, AWAIT, ESCALATE, REVISE_PLAN) — tratează ABSTAIN/ESCALATE ca opriri ferme, nu ca erori peste care reîncerci.
5. Rulează python -m fpf_thinking_map.verify ca să dovedești că harta e bine formată, înainte s-o conectezi la ceva expus utilizatorilor.
6. Nu inventa porți, roluri sau tranziții care nu reflectă riscul real al acestui proiect — o hartă neutilizată, decorativă, e mai rea decât lipsa unei hărți.

Referință: fpf_thinking_map/README.md din pachetul instalat, și ARCHITECTURE.md din repo pentru semantica completă a rezultatelor și porților.

Vrei să-l încerci fără să scrii cod? Mod utilizator vs. mod dezvoltator, în Claude Code

Șase pași de instalare, apoi alegi ce vrei să faci:

1. 1.Clonează repo-ul — git clone https://github.com/Consolidare-Continuum/fpf-agentic-thinking-map
2. 2.Intră în folder — cd fpf-agentic-thinking-map
3. 3.Instalează local — pip install -e .
4. 4.Instalează serverul de test — pip install -r dev_mcp/requirements.txt
5. 5.Verifică-l — python -m dev_mcp.test_server — trebuie să vezi 42/42
6. 6.Adaugă-l în Claude Code, dintr-o comandă — claude mcp add fpf-test -- python -m dev_mcp.server

Ambele sunt modul de inspectat, nu cel de producție — perfect ca să-l simți în 10 minute înainte să decizi dacă merită integrat undeva serios. Pentru producție, folosești direct codul de context de mai sus, în propriul tău proces.

Obiecte principale

SemanticMap	Structura statică și relațiile permise.
RuntimeBinding	Rolul, starea și dovezile curente.
ThinkingMapTraversal	Selectarea candidaților, porțile și rezultatul.

Rezultate tipizate

9 rezultate live din 11 declarate — CONTINUE · ABSTAIN · COLLECT_EVIDENCE · CHANGE_FRAME · IDLE · BRIDGE · AWAIT · ESCALATE · REVISE_PLAN. Nefolosite încă: ASK, PUBLISH.

Documente din repository

• README ↗
• fpf_thinking_map/README.md — sursa codului de context ↗
• ARCHITECTURE ↗
• REFLECTIONS ↗
• dev_mcp — serverul de test folosit mai sus ↗
• GitHub ↗

Vrei asta în propriul proiect?

Nucleul de bază e liber, sub licență MIT — îl poți lua și dezvolta mai departe cu propria echipă, fără să ai nevoie de noi pentru asta. Dar dacă dorești să integrezi ATM împreună cu noi — ca și consultanți sau ca dezvoltatori, într-un sistem agentic real: finanțe, e-commerce, orice unde un agent trebuie să respecte un cadru, nu doar să improvizeze — scrie direct: consolidare_continuum@proton.me — adresa mentenanței proiectului, citesc și răspund eu, nu un formular de contact anonim.