Health check — returns pong and the server version.

Compress a payload (JSON / code / prose) into a token-cheap skeleton. The exact original is stored locally and recoverable via knitbrain_retrieve using the returned ⟨recall:hash⟩. Returns the original unchanged if compression wouldn't help.

Retrieve the exact original bytes for a ⟨recall:hash⟩ handle produced by compression. Use when a skeleton isn't enough and you need the precise content.

Read a project file OPTIMIZED: returns a structure-preserving skeleton (signatures/schema kept, bulk elided) + a ⟨recall:hash⟩ to page in the exact original. Use INSTEAD of the host's raw read for large files — same information shape, ~70-90% fewer tokens. Works on every platform.

Record a non-obvious project learning (summary + lesson + tags) for future sessions.

Search project learnings; returns ranked headlines (id + summary). Call knitbrain_get_learning for a full lesson.

Fetch the full lesson for a learning id (from knitbrain_search_learnings).

Close the loop on a recalled learning: report whether it actually HELPED on this task (a concrete outcome, not 'noted'). Useful learnings rise in future recall; ones reported wrong are discredited and sink, and a correction note folds into the lesson so the next recall carries the fix. This is what turns memory from a log into something that compounds.

Save session handoff state so the next session can resume.

Load the prior handoff + top recent learnings to resume work. Resets the context meter for the new session.

Token-window meter: how full the context is, tokens saved by optimization, and whether it's time to save a handoff and clear the session.

Retrieval layer (input SELECTION): query → ranked function/class-level chunks (signature + location, NOT whole files) + graph-connected related files, score-gated so no low-relevance context is served. Use BEFORE reading files: search, then knitbrain_read ONLY the hits you need — sending less beats compressing more.

Scan the project and (re)build the import/export knowledge graph.

What a file imports (module specifiers + names).

What a file exports.

Which files import the given file (blast radius before editing).

Classify a task into a tier (inquiry/trivial/standard/complex) with phases + plan-mode signal. Follow the returned plan.

The classifier got it wrong? Record it: claimed tier vs what the task actually was. After 3 same-direction reports the classifier's threshold self-adjusts (per-project, deterministic, bounded).

Compression telemetry: recall-store tier counts + per-kind retrieval rates (TOIN self-tuning).

Auto-detect project-specific agent proposals from the knowledge graph (domains + guardrails). Review/edit, then create with knitbrain_create_agent.

Generate a project-specific subagent (.claude/agents/.md) with 4 guardrails: file scope, allowed-tools, optional review gate, context budget.

THE feedback/orchestrator tool — call FIRST when the user states a task. Classifies it (small→big), finds-or-drafts the SKILL for it, proposes guardrailed agents when multi-domain, lists host slash-commands the agent can run itself, and reports the context meter. Follow the returned directive.

Compose a NEW project-tailored skill for a task in the USER'S OWN composition style (learned from their existing .claude/skills — length, terseness) and persist it. Use when no existing skill fits; refine the body, then knitbrain_skill_save to update.

Persist a refined skill playbook (telegraphic). Same name updates the skill — skills compound across tasks. constraints are non-negotiable guardrails that propagate into every agent briefed with the skill.

Close the loop on a skill: report whether it actually WORKED after using it (a test passing, a bug fixed — a concrete outcome, not 'task complete'). Failures with a note fold into the playbook's pitfalls; skills that keep failing get flagged needs-revision instead of being re-served.

Post a finding to the shared team board (stored compressed; full original recoverable).

Read the shared team board — compressed skeletons of every posting (cheap to scan; fetch full with knitbrain_team_get).

Fetch the full original of a board posting by id.

Clear the shared team board (recall originals are retained until tiered out).

Ingest a synthesized note into the compounding wiki-brain: writes/updates a terse page, rebuilds the index, appends the log, and stubs any cross-referenced page. Use to compound knowledge across the session (entities, concepts, summaries, session notes) instead of letting it vanish into chat.

Query the wiki-brain: returns the index catalog + recent log so you can drill into the relevant pages (read them with knitbrain_read). File good answers back with knitbrain_wiki_ingest so explorations compound.

Health-check the wiki-brain: flags claim contradictions across pages (incl. stale claims superseded over time) and orphan pages nothing links to.

Hard claim-check (anti-hallucination): parse a stated codebase fact and check it against the knowledge graph. Supported shapes: " imports ", " exports ", " is a dependent of " / " depends on ". Returns verified | contradicted | unparseable so a claim is settled by the graph, not by assertion.

Unified brain recall (gap #8): fan a query across ALL typed stores — learnings (BM25), the wiki, and the knowledge graph — and return ranked hits each tagged with the store it came from. One call instead of search_learnings + wiki_query + query_* separately. Drill into a hit with the matching typed tool (knitbrain_get_learning / knitbrain_read / knitbrain_query_*).

The front door: onboard a project into the brain. Call with NO args first — it scans the repo + imports this project's past sessions into the wiki, then returns 5 intent questions; ask the user those IN CHAT, then call again with answers (array, in order) to write a Project Charter + constraints that shape the loop and re-surface every session. Run once per project after setup.

Autonomous goal loop (ONE cycle per call). Runs your verify_cmd as the REAL hard gate, tracks iteration across calls, and drives until the goal is met or max_iters. HONEST: the HOST AGENT does the actual work BETWEEN cycles — this tool does NOT edit code. Each call runs the verify gate; if not met it returns a per-cycle directive telling you to make the smallest fix and call again. Stops at grade-pass (met=true) or max_iters (met=false).

Self gap-check (keystone): runs the brain's anti-* invariants in ONE pass and auto-fixes what it can. Re-scans the graph (anti-stale), auto-heals wiki contradictions (Gap-E resolve), confirms a stored workflow surfaces every session (anti-drift), flags learnings recorded with no verify_claim behind them (anti-sycophancy), and reports the adherence write-gate state. Returns a PASS/FAIL invariant table + fixes applied + residual gaps a human must close. Composes the existing detectors — no duplicate logic.