Skip to main content
Glama

claude-faf-mcp

npm version Smithery FAF ✪ 100% IANA: vnd.faf+yamlIANA: vnd.fafm+yaml DOI: Context paperDOI: Memory paper

Home: faf.one/mcp Site: claude.faf.one

Persistent Project Context with Memory, looped for you. One-click setup. 🐘 Nelly Never Forgets.

MCP Registry: one.faf/claude-faf-mcp CI NPM Downloads License: MIT Chat to FAFA live Business card · Get yours →

FAF defines. MD instructs. AI codes.

⭐ Star faf-cli on GitHub, the CLI this server is built on: bookmarks it for you, helps other devs find it too.

v0.2-conformant reader of the FAF Context Ingestion Contract.

🐘 tri-sync | .faf → MEMORY.md (faf_tri_sync), alongside .faf → CLAUDE.md (faf_sync).

⚡ The faf prompt — pick it from your host's prompt list (Claude Code shows it as /mcp__<server name>__faf). It scores your project, fills what the repo can, asks you only what only you can answer, verifies, and syncs.

7.0.0 is a major release — scores can move. claude-faf-mcp now scores with faf-cli 8's always-33 engine. A .faf without the 12 enterprise slotignored markers counts them as empty (21 filled = 64%): run faf_auto and it writes the markers. The npx config and the SessionStart hook are not pinned to a version, so an install that runs npx -y claude-faf-mcp moves to 7.x on its next start. Every change is in the CHANGELOG.

Context for Claude: faf-cli writes this repo's CLAUDE.md from its scored project.faf — faf_sync here, faf sync in faf-cli. See FAF-CLI for Claude Code 👀.

Composes faf-cli (the version is pinned in package.json). Detection, scoring, the renders and every writer are faf-cli's own functions, loaded as a dependency; claude-faf-mcp does not fork them and never runs a faf found on your PATH.

Core 14 MCP tools (30 with FAF_TOOLS=all). IANA-registered formats (application/vnd.faf+yaml · application/vnd.fafm+yaml).


What's New in v7.2.0 — The Human Slots Edition

Claude suggests, you confirm. claude-faf-mcp no longer writes your project's goal or six W's: faf_go shows each suggestion with its source, and only what you confirm is written.

  • Suggestions with their source. faf_go offers faf-cli's suggestion for each empty goal or W, with where it came from (README.md § Why, package.json description). Claude shows it for you to accept or edit; only your answers are written.

  • faf-cli 8.10.0 inside. faf_init, faf_auto and faf_git leave the goal and six W's empty, so a new project.faf scores lower, honestly, and they say how many suggestions are waiting. Files you already have are not changed.

  • faf_readme suggests and never writes, from README, package.json or Cargo.toml. faf_git returns the repo's suggestions before its temporary clone is gone.

  • CI on the faf-cli users get. A daily run tests the server against faf-cli@latest.

  • 7.2.1: faf_go's closing line keeps the goal and six W's apart from stack slots: they are the user's to give, never "no fact in repo".

Related MCP server: gemini-faf-mcp

v7.1.0 — The Instructions Edition

claude-faf-mcp now tells Claude how its tools fit together: server instructions in initialize (637 characters), plus faf-cli 8.5.0, which knows a skills repo when it sees one.

  • Server instructions. When Claude connects, the server says how its tools fit together, in five short lines: one project at a time, read project.faf first, ask the user for the human answers, project.faf is the source, remember only when asked.

  • faf-cli 8.5.0 inside. faf_init and faf_auto detect a skills repo: SKILL.md folders make it skills (10 slots), and a Claude Code plugin manifest makes it skills-plugin (14).

  • --version and --help print and exit, instead of starting the server.

  • Three advisories cleared: the MCP SDK, zod and hono.

The Always33 Edition (7.0)

One engine, one number: claude-faf-mcp 7 scores with faf-cli 8's always-33 kernel — the same score faf-cli and faf-kernel give.

  • The always-33 engine. Every tool scores with faf-cli 8.0.0 — all 33 Mk4 slots, one Rust kernel. Checked live: faf-python-sdk 56, mcp-context-card 56, faf-cli ✪ 100, the same numbers faf-cli and the reference scorer give.

  • Your 21 slots, and the 12 enterprise slots in view. The enterprise slots (infra, app, ops) are marked slotignored unless your app-type uses them. faf_score scores against all 33; slotignored slots drop out of the denominator.

  • Upgrading: a .faf without the 12 markers now scores against 33. Run faf_auto — it writes them and your score returns (56% → ✪ 100% on a real v7-era file).


v6.0.0 — The Earned Badge Edition

Every badge earned, none claimed: claude-faf-mcp 6.0 composes faf-cli, touches only what it wrote, and every tool tells the truth — one score, facts from repo, nothing from your PATH.

  • Composes faf-cli 7.13. Detection, scoring, the renders and every writer are faf-cli's own functions. claude-faf-mcp never runs a faf it finds on your PATH.

  • Touches only what it wrote.

    • Every write is atomic and goes through faf-cli's safe path, and a file that links out of the project is refused.

    • project.faf edits keep your comments and exact values.

    • Your soul.fafm and Claude's own MEMORY.md notes stay as you left them.

  • One score. Every tool shows faf-cli's score, and ✪ appears only at 100%.

  • Facts from repo. Every empty slot says what fills it:

    • a fact from repo, which faf_auto writes;

    • no fact in repo, which you answer with faf_go;

    • or yours, for the 6Ws.

  • Tools that tell the truth.

    • Every title, hint and schema matches what the tool does, and bad arguments are refused before anything runs.

    • Core 14: faf_setup and faf_tri_sync join the default list.

  • Safe with any repo.

    • A cloned repo's symlinks never reach your AI's context.

    • faf_go answers can't pollute objects.

    • The file tools stay inside the active project.

  • Ships what it runs. The .mcpb runs the server bundled inside it, and it's started and checked before its sha is recorded. Node 22+, with CI on Node 22 and 24 across Ubuntu, macOS and Windows.

  • Retired: faf_clear, faf_friday, faf_guide, faf_write, the interop imports into project.faf, and faf_check protect/unlock. The archive tag archive/cfm-v5-surface keeps them.


The 3Ws — 3 Answers. That's It.

Every great product started with 3 answers to the 3Ws — Who, What, Why:

WHO is it for?

WHAT does it do?

WHY build it?

Uber

People who need a ride

Tap a button, car arrives

Taxis were broken

Airbnb

Travelers who can't afford hotels

Stay in someone's spare room

Millions of empty rooms exist

Slack

Teams drowning in email

Organized group messaging

Decisions buried in threads

Venmo

Friends splitting bills

Send money instantly

Someone always forgets to pay back

Same pattern. Every product that works starts here. .faf captures it:

human_context:
  who: "people who need a ride across town"
  what: "tap a button, car arrives in minutes"
  why: "taxis are slow, expensive, and hard to find"

Claude builds your project.faf from this. Every session after, AI starts smart.

The 6Ws — For Optimized AI

3Ws gets you started. For fully optimized AI, complete the set — Where, When, How:

  where: "mobile app, iOS and Android"    # where does it live?
  when: "beta since March 2026"           # what stage, and since when?
  how: "GPS matching, real-time pricing"  # how does it work?

3Ws initiates the project with AI. 6Ws optimizes AI to 100%. Same YAML, same file. More examples → faf.one/ideas


Quick Start

Needs Node 22 or later.

Claude Desktop — one click

⬇ Download claude-faf-mcp-7.2.1.mcpb

Open it in Claude Desktop. The extension runs the server bundled inside it (no npx, no network at start) and lists the Core 14 tools.

Claude Desktop — config

Add to claude_desktop_config.json, then restart Claude Desktop:

{
  "mcpServers": {
    "faf": { "command": "npx", "args": ["-y", "claude-faf-mcp"] }
  }
}

After npm install -g claude-faf-mcp you can use the installed bin instead: { "command": "claude-faf-mcp" }. With Bun on Claude Desktop's PATH, { "command": "bunx", "args": ["claude-faf-mcp"] } works too.

Claude Code

claude mcp add faf -- npx -y claude-faf-mcp

Pinning

The npx config and the SessionStart hook faf_setup installs (npx -y claude-faf-mcp --session-refresh) are not pinned: they run the latest release, so fixes arrive without a reinstall, and a new major arrives the same way. To stay on a major, write it in your config yourself: "args": ["-y", "claude-faf-mcp@6"]. The .mcpb runs the version it was built from.

Then

Run the faf prompt — Claude scores your project, fills what the repo can, asks you what only you can answer, verifies and syncs.

Or tell Claude your 3Ws: "I'm building [what] for [who] because [why]"

faf-cli — any terminal

npx faf-cli auto

Same .faf, every surface — Claude, Gemini, Grok, Cursor. faf-cli on npm →


How It Works

You → 3 answers → project.faf → AI reads it → every session → forever

project.faf  ──→  CLAUDE.md     (faf_sync)
project.faf  ──→  MEMORY.md     (faf_tri_sync 🐘)

Language, framework, package manager, build tools — faf-cli detects them from your existing files. The human context is the part only you can give.


For Claude Code teams

.faf lives in the repo. Your context travels with the code — committed, versioned, done.

Every session starts grounded. Install the native SessionStart hook once (faf_setup — preview first, your settings preserved). After that, every Claude Code session opens with a one-line heartbeat instead of a blank slate:

faf: context ✪ 100% — fresh · +7 intent the code can't carry

That line is the relay: Claude already knows your stack and your score — and the +N is the intent the code can't carry: the goal and 6Ws only you can give or confirm. No re-explaining "what this project is" at the top of every session.

It scales to the team by construction:

commit project.faf  →  every teammate's Claude starts with the same context
git clone           →  a new dev's Claude is grounded before they write a line
  • One source of truth. faf_sync writes CLAUDE.md from .faf — only its faf-managed block, so your own notes stay put. Add MEMORY.md for cross-session memory (tri-sync 🐘).

  • No drift. The score is deterministic — same .faf, same number, on every machine and in CI. A teammate can't be accidentally less grounded than you.

  • Local. No accounts, no telemetry, nothing sent to FAF. The one network use is cloning a repo you name, only when you ask (privacy). The context is yours; it rides in the repo.

Onboarding becomes git clone → grounded. The context a new teammate would normally pick up by asking around is already in the repo, machine-readable, from the first clone.


Scoring: From Blind to Optimized

Tier

Score

What it means

✪ TROPHY

100%

AI is optimized to code

★ GOLD

99%+

Near-perfect context

◆ SILVER

95%+

Excellent

◇ BRONZE

85%+

Production ready

● GREEN

70%+

Solid foundation

● YELLOW

55%+

AI flipping coins

○ RED

<55%

AI working blind

♡ WHITE

0%

No context at all

At 55%, AI guesses half the time. At 100%, AI knows your project. The score is faf-cli's scoreFafYaml — the always-33 number faf score prints for the same file.


MCP Tools — Core 14, 30 with FAF_TOOLS=all

Every tool with a real call and its output: TOOLS.md.

By default claude-faf-mcp lists the Core 14 — the lifecycle tools you reach for. Set FAF_TOOLS=all to list the Extended tools too; every tool is callable by name either way. Retired in 6.0.0: faf_clear, faf_friday, faf_guide and faf_write (a call by name returns one line naming what to use instead), the AGENTS.md / .cursorrules / GEMINI.md / conductor imports into project.faf, and faf_check protect/unlock.

Every tool runs on the faf-cli this package depends on. Nothing is run from your PATH.

Core

Tool

Purpose

faf_init

Create project.faf for a folder (faf-cli detects the stack)

faf_auto

Fill project.faf from the repo's own files, then CLAUDE.md

faf_go

The goal and the 6Ws: suggestions from the repo, with their source, for you to confirm

faf_score

AI-readiness score (0-100%), from faf-cli

faf_bench

Benchmark AI grounding — cold vs with the .faf, graded mechanically, with a receipt

faf_doctor

Diagnose project.faf: each finding with the tool that fixes it

faf_trust

Validate project.faf and return a trust receipt for its score

faf_sync

Write CLAUDE.md from project.faf — agents/cursor/gemini/copilot/all also write AGENTS.md / .cursorrules / GEMINI.md / copilot-instructions.md

faf_tri_sync

Write faf's block into the MEMORY.md Claude Code loads for this project 🐘

faf_setup

Install the SessionStart hook in the project settings (preview first)

faf_context

Show or set the active project; detail returns the .faf text

faf_etch

Remember a decision across sessions (the project soul, soul.fafm)

faf_recall

Recall memories from the project soul

faf_about

What the .faf format is

Extended (FAF_TOOLS=all)

Tool

Purpose

faf

Start here: the project, its score and the steps to 100% (reads only)

faf_quick

Create project.faf from one line: name, goal, language, framework, hosting

faf_readme

Suggest the goal and 6Ws from README, package.json and Cargo.toml, each with its source; writes nothing

faf_human_add

Set one 6W slot in project.faf to text you confirmed

faf_formats

The formats faf-cli finds in the folder, and what faf_auto would write (dry run)

faf_git

Author a project.faf from a repo URL (clones it with git — uses the network); the goal and 6Ws stay empty, and the repo's suggestions are returned

faf_check

faf-cli's validateFaf and the state of every slot

faf_dna

The project's .faf-dna lineage (reads only)

faf_status

Whether the project has a .faf, with its first lines

faf_agents

Write AGENTS.md (OpenAI Codex and other agents)

faf_cursor

Write .cursorrules (Cursor IDE)

faf_gemini

Write GEMINI.md (Google Gemini CLI)

faf_conductor

Write Google Conductor's conductor/ files

faf_read

Read a file inside the active project

faf_list

List a folder inside the active project

faf_debug

The active project, write access and the bundled faf-cli version


🐘 Nelly Never Forgets

faf_sync writes CLAUDE.md from .faf, so the two stay aligned.

tri-sync adds MEMORY.md — your AI remembers your project across every session.

faf_sync = .faf → CLAUDE.md              ← written from .faf
tri-sync = .faf → MEMORY.md   (faf_sync writes CLAUDE.md)  ← Nelly never forgets 🐘

Pro feature, free for developers. Teams & Enterprise: faf.one/pro (plans)


The .FAF Position

Model        Context          Protocol
─────        ───────          ────────
Claude    →   .faf        →    MCP
Gemini    →   .faf        →    MCP
Codex     →   .faf        →    MCP
Any LLM   →   .faf        →    MCP

IANA-registered (application/vnd.faf+yaml). One file, one format. Define once, use everywhere.


Ecosystem

Package

Platform

Registry

claude-faf-mcp (this)

Claude

npm

faf-cli

CLI

npm + Homebrew

gemini-faf-mcp

Google Gemini

PyPI

grok-faf-mcp

xAI Grok

npm

rust-faf-mcp

Rust

crates.io

faf-wasm

Browser/Edge

npm

Chrome Extension

Browser

Chrome Web Store

Same project.faf. Same scoring. Same result. Different execution layer.


Quality

Tests run with bun on ubuntu, macOS and Windows; the built package is packed, installed and started on Node 22 and 24 on all three. CI →


Privacy

claude-faf-mcp runs on your machine. No analytics, no telemetry, no accounts. Its one network use is faf_git, and only when you ask it to read a repo: git clones it from the URL you give. The files it writes are listed in the privacy policy →


If claude-faf-mcp has been useful, consider starring the repo — it helps others find it.


Citation

If you use claude-faf-mcp or the .faf / .fafm / .fafa formats in research or production, please cite the format papers:

Wolfe, J. (2025). Format-Driven AI Context Architecture: The .faf Standard for Persistent Project Understanding. Zenodo. https://doi.org/10.5281/zenodo.18251362

Wolfe, J. (2026). Permanent Memory and Instant Recall: The .fafm Standard for Multi-Profile AI Agent Memory. Zenodo. https://doi.org/10.5281/zenodo.20348942

Wolfe, J. (2026). Why Agents Need a Passport: .fafa — Portable Identity for the Agentic Era. Zenodo. https://doi.org/10.5281/zenodo.21951641

BibTeX

@article{wolfe2025faf,
  title     = {Format-Driven AI Context Architecture: The .faf Standard for Persistent Project Understanding},
  author    = {Wolfe, James},
  year      = {2025},
  month     = {nov},
  publisher = {Zenodo},
  doi       = {10.5281/zenodo.18251362},
  url       = {https://doi.org/10.5281/zenodo.18251362}
}

@article{wolfe2026fafm,
  title     = {Permanent Memory and Instant Recall: The .fafm Standard for Multi-Profile AI Agent Memory},
  author    = {Wolfe, James},
  year      = {2026},
  month     = {may},
  publisher = {Zenodo},
  doi       = {10.5281/zenodo.20348942},
  url       = {https://doi.org/10.5281/zenodo.20348942}
}

@article{wolfe2026fafa,
  title     = {Why Agents Need a Passport: .fafa — Portable Identity for the Agentic Era},
  author    = {Wolfe, James},
  year      = {2026},
  month     = {aug},
  publisher = {Zenodo},
  doi       = {10.5281/zenodo.21951641},
  url       = {https://doi.org/10.5281/zenodo.21951641}
}

License

MIT — Free and open source


FAF Family

faf-cli

npx faf-cli init — create .faf for any project

claude-faf-mcp

MCP server for Claude Desktop

gemini-faf-mcp

MCP server for Gemini CLI

grok-faf-mcp

MCP server for Grok

faf-mcp

MCP server for Cursor, Windsurf, Cline, VS Code

rust-faf-mcp

MCP server in Rust

faf-skills

Claude Code skills for .faf

faf.one

Blog, downloads, docs

IANA: vnd.faf+yaml

Context format (2025-10-30)

IANA: vnd.fafm+yaml

Memory format (2026-05-13)

format | driven 🏎️⚡️ wolfejam.dev


Get the CLI

faf-cli — The original AI-Context CLI. A must-have for every builder.

npx faf-cli auto

MCP Registry: one.faf/claude-faf-mcp · 2 IANA registrations: vnd.faf+yaml (Context) · vnd.fafm+yaml (Memory) · faf.one · npm


Zero-Config. Context that's just there — every session.

Available Tools

14 tools
faf_aboutAbout .fafA
Read-onlyIdempotent
Inspect

Explain what the .faf format is — project context for AI, IANA-registered as application/vnd.faf+yaml — and how this server uses it. Returns a short plain-text overview with this server's version. Reads nothing and writes nothing. Use it when someone asks what FAF is.

Inputs: no named parameters.

faf_autoFill from the RepoA
DestructiveIdempotent
Inspect

Create /project.faf, or fill the empty slots of the one there, with faf-cli's detection over the repo's own files (package.json, Cargo.toml, pyproject.toml, go.mod…) — no hardcoded defaults. A value already there is kept. A typed None or placeholder word is an empty slot: in a tech slot the app-type uses, only a repo fact replaces it (with no fact it stays as typed); in a tech slot the app-type leaves out, faf_auto writes slotignored; in a 6W it stays as typed (faf_go asks). Every value it changes is listed. Then writes CLAUDE.md's faf-managed block. Returns what was filled and faf-cli's score before and after. faf_go does the human 6Ws.

Inputs: path.

faf_benchGrounding BenchmarkA
Read-onlyIdempotent
Inspect

Prove the .faf earns its place — measure how much the context is worth, on THIS repo, falsifiably. Questions derive from the project.faf's own populated slots (the .faf is the answer key), so grading is mechanical — no judge, no rubric. action=questions returns the answer-key-safe question set; action=grade takes your answers WITHOUT the .faf (cold) and WITH it (faf), grades both, and returns the cold→with-faf lift with a receipt hash. The delta is the product; the cold number belongs to the absence of context, never to FAF. Reads only.

Inputs: faf, cold, path, model, +3 more. Returns: Question set (action=questions) or the cold→with-faf grading and its receipt (a…

faf_contextActive ProjectA
Read-onlyIdempotent
Inspect

Show the active project — the folder every faf_* call without a path uses — and the .faf there; pass path to make another folder the active project (your home folder and the filesystem root are refused). detail: true also returns the .faf's text. Writes no file. Call it once at the start of a session.

Inputs: path, detail. Returns: The active project context and whether a project.faf lives there.

faf_doctorDiagnose .fafA
Read-onlyIdempotent
Inspect

Diagnose the project's .faf: faf-cli's validateFaf errors, faf-cli's score with every empty slot and the tool that fills it (faf_auto from the repo, faf_go for the 6Ws), whether CLAUDE.md is there, and the formats faf-cli finds in the folder. Returns a checklist of findings, each with its fix. Reads only. Use it when faf_score is below 100%.

Inputs: path. Returns: Health check: an overall verdict plus per-check diagnostics with fixes.

faf_etchEtch MemoryA
Destructive
Inspect

Remember a decision, gotcha, or win across sessions by writing it to the project soul (soul.fafm) with faf-cli's Soul. Returns the stored memory and the soul's size. Re-etching an id updates that memory in place. Use it to persist something an AI should recall later; faf_recall reads them back.

Inputs: text (required), id, path, tags, +2 more. Returns: The etched fact + soul state.

faf_goGuided InterviewA
Destructive
Inspect

The human half of project.faf. Without answers it returns the Table-of-8 — project name, goal and the 6Ws (who, what, why, where, when, how) — each filled, seeded from the goal, or empty, with faf-cli's score and, for each slot still empty, whether it is a fact from repo (faf_auto writes it: its dry run, the one faf_formats shows) or needs an answer here. An empty goal or W carries faf-cli's suggestion from the repo with its source, for the user to confirm. With answers (slot path → the text the user confirmed, e.g. {"human_context.why": ""}) it writes them into /project.faf in place and returns the new score; a value already in a slot you answer is replaced. With no project.faf yet it runs faf_init and faf_auto first. faf_auto writes each fact from repo; a stack slot with no fact in repo is answered here.

Inputs: path, answers.

faf_initCreate project.fafA
Destructive
Inspect

Create a new project.faf for a folder: faf-cli detects its name, language and stack, and the reply gives the file path, faf-cli's starting score and the birth .faf-dna. An existing project.faf is left as it is — use faf_auto to fill its empty slots from your manifests, or faf_go for the human 6Ws. force: true replaces an existing project.faf with a fresh one, after copying the old file to a backup beside it.

Inputs: path, force.

faf_recallRecall MemoryA
Read-onlyIdempotent
Inspect

Recall memories from the project soul (soul.fafm), ranked by priority then recency, filtered by query/tags/type. Returns the matching entries. Reads only. Use it to surface past decisions; faf_etch adds new ones.

Inputs: path, tags, type, limit, +2 more. Returns: Ranked memories from the soul.

faf_scoreScore .fafA
Read-onlyIdempotent
Inspect

Score the project's .faf with faf-cli's scorer — the one score every faf tool reports: 0–100%, the tier, populated/active slots, and a faf-parity/v1 hash of the result. details: true lists every slot as populated, empty or slotignored. Reads only. Use faf_doctor for what to fix.

Inputs: path, details. Returns: Structured AI-readiness score, single-sourced from faf-cli.

faf_setupSession Hook SetupA
Idempotent
Inspect

Install the native SessionStart hook in the project settings (/.claude/settings.json) — every Claude Code session in this project starts with fresh .faf context. Shows the exact settings first (preview); writes only with confirm: true, install or remove. faf changes only its own hook entry; every other key and hook stays as written. remove: true takes out only the hook whose command is exactly the faf hook command. Never writes the user settings: the home folder is refused.

Inputs: path, remove, confirm. Returns: Setup result: what happened (or would happen) to .claude/settings.json.

faf_syncSync .faf to CLAUDE.mdA
Idempotent
Inspect

Write project.faf into CLAUDE.md as a faf-managed block (faf-cli's render and injector), and on request into AGENTS.md (agents), .cursorrules (cursor), GEMINI.md (gemini) and .github/copilot-instructions.md (copilot) — or all of them (all) — with faf-cli's writers. Each file keeps every line outside faf's block. Returns the files written and any requested file that could not be written, with the reason (then isError). Use it after editing project.faf.

Inputs: all, path, agents, cursor, +2 more. Returns: The files faf_sync wrote, and each requested file it could not write.

faf_tri_syncTri-Sync to MEMORY.mdA
Idempotent
Inspect

Write project.faf as a faf-managed block into the MEMORY.md Claude Code loads for this project (~/.claude/projects//memory/MEMORY.md, or under CLAUDE_CONFIG_DIR). Only the block changes; every note of Claude's is kept, and the reply says so only after reading the file back. action: status reads only. faf_sync writes CLAUDE.md.

Inputs: path, action.

faf_trustTrust ReceiptA
Read-onlyIdempotent
Inspect

Attest the project's .faf: faf-cli's validateFaf, faf-cli's score, and a faf-parity/v1 hash (claude-faf-mcp's own spec) of that score that anyone can check with sha256(projection) === parityHash. Returns a trust receipt whose subject is the project. An invalid .faf, or a score that is unknown, gets no receipt (isError). Reads only.

Inputs: path. Returns: Trust attestation: faf-cli's validity and score, and a faf-parity/v1 receipt.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A4.1/5.0

    Scored across 14 tools

    Disambiguation4/5

    Most tools have sharply distinct purposes (init=create, auto=fill from repo, go=human 6Ws, sync=CLAUDE.md, tri_sync=MEMORY.md, etch/recall=memory), and the descriptions explicitly cross-reference and disambiguate. The weak spot is the read-only score cluster — faf_score, faf_doctor, faf_trust, and faf_bench all report a score/hash, and an agent must parse dense prose to decide which to call.

    Naming Consistency5/5

    Every tool follows the same faf_<short_verb_or_noun> snake_case pattern with no casing or prefix deviations. The suffixes (init, auto, go, score, sync, tri_sync, etch, recall) are readable and predictable.

    Tool Count5/5

    14 tools sit comfortably in the ideal range for a CLI-backed project-context server. Each maps to a real, named step in the .faf lifecycle, and none look like filler.

    Completeness4/5

    The surface covers the full lifecycle: create, fill (machine and human), validate/score, attest, render to five target files, install a session hook, benchmark value, and persist/recall memory. Minor gaps: no way to delete a .faf or 'forget' an etched memory (etch updates but never removes), and no multi-project listing beyond faf_context.

    Maintenance

    ActivityActive
    ResponsivenessLimited data

    Related MCP Connectors

    Related MCP Servers