Agent skill

Nav Graph

by qf-studio in qf-studio/navigator

Query project knowledge graph. An agent skill from qf-studio/navigator.

MITAuto-check: notesKnowledge Management

Install Nav Graph

skills CLI
$ npx skills add qf-studio/navigator --skill nav-graph -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install qf-studio/navigator nav-graph --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/qf-studio/navigator.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/nav-graph .claude/skills/nav-graph && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
nav-graph
GitHub stars
355
Token cost
~5.9k tokens
SKILL.md length
1,447 words
Files
18
Skills in repo
32
Repo updated
First seen
Licence
MIT

At a glance

Query project knowledge graph. An agent skill from qf-studio/navigator.

  • Works in 3 steps: Determine Action → Load or Initialize Graph → Find Related (Optional)
  • User asks what do we know about X?
  • SKILL.md covers Why This Exists, When to Invoke, Graph Location and Execution Steps, plus 5 more sections
  • Runs Python scripts from its folder; calls python3

What it does

Nav Graph is an agent skill from qf-studio/navigator. Query project knowledge graph. Search across tasks, SOPs, memories, and concepts. Use when user asks "what do we know about X?", "show everything related to X", or "remember this pattern/pitfall/decision".

Its SKILL.md is about 5.9k tokens, which your agent loads only when the skill is triggered. The skill folder holds 19 other files (for example `functions/correction_to_memory.py`, `functions/execution_to_graph.py` and `functions/graph_builder.py`).

It sits in Knowledge Management, covering Knowledge graphs and Operations and SOPs. The repository describes itself as: Finish What You Start — Context engineering for Claude Code. Sessions last 20+ exchanges instead of crashing at 7. The licence is MIT.

When your agent uses it

  • User asks what do we know about X?
  • Show everything related to X
  • Remember this pattern/pitfall/decision

Example prompts

  • “what do we know about X?”
  • “show everything related to X”
  • “remember this pattern/pitfall/decision”
  • “/nav-graph”

Requirements

  • Python 3
  • Pre-approved tools (allowed-tools): Read, Write, Edit, Bash

Workflow steps

3 steps, taken from the step headings in SKILL.md.

  1. Determine Action
  2. Load or Initialize Graph
  3. Find Related (Optional)

What it can do on your machine

Read from SKILL.md and the folder at commit 3bb9eac. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves these tools, so the agent can use them without asking each time:

    • Read
    • Write
    • Edit
    • Bash

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Ships script files (Python), which the agent can run.

    Shell commands in SKILL.md call:

    • python3

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Nav Graph loads about 5.9k tokens when it runs. Until then it costs about 54 tokens; SKILL.md has 1,447 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~54
When it runs · the whole SKILL.md, loaded when a task matches
~5.9k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check: notes

The automated check noted patterns worth knowing about, such as sudo or a known installer.

  • NotePre-approves every shell command (allowed-tools: Bash)SKILL.md
    allowed-tools: Read, Write, Edit, Bash

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from qf-studio/navigator at commit 3bb9eac, republished under its MIT licence (© qf-studio). 1,447 words, ~5,863 tokens.

Download SKILL.mdSave it as .claude/skills/nav-graph/SKILL.md (or your agent's skills folder). This skill also uses 17 other files; get the full folder from GitHub.
name
nav-graph
description
Query project knowledge graph. Search across tasks, SOPs, memories, and concepts. Use when user asks "what do we know about X?", "show everything related to X", or "remember this pattern/pitfall/decision".
allowed-tools
Read, Write, Edit, Bash
version
1.0.0

Navigator Knowledge Graph Skill

Query and manage the unified project knowledge graph. Surfaces relevant knowledge from tasks, SOPs, system docs, and experiential memories.

Why This Exists

Navigator v6.0.0 introduces the Project Knowledge Graph:

  • Unified search: Query across all knowledge types with one interface
  • Experiential memory: Patterns, pitfalls, decisions, learnings persist
  • Context-aware retrieval: Load only relevant knowledge (~1-2k tokens)
  • Relationship traversal: Find related concepts and documents

When to Invoke

Query triggers:

  • "What do we know about X?"
  • "Show everything related to X"
  • "Any pitfalls for X?"
  • "What decisions about X?"
  • "Find all knowledge about X"

Memory capture triggers:

  • "Remember this pattern: ..."
  • "Remember this pitfall: ..."
  • "Remember we decided: ..."
  • "Remember this learning: ..."

Graph management triggers:

  • "Initialize knowledge graph"
  • "Rebuild knowledge graph"
  • "Show graph stats"

Graph Location

.agent/knowledge/graph.json (~1-2k tokens, loaded on query)

Execution Steps

Step 1: Determine Action

QUERY (searching knowledge):

User: "What do we know about authentication?"
→ Query graph by concept

CAPTURE (storing memory):

User: "Remember: auth changes often break session tests"
→ Create new memory node

INIT (building graph):

User: "Initialize knowledge graph"
→ Build graph from existing docs

STATS (viewing graph):

User: "Show graph stats"
→ Display graph statistics
Step 2: Load or Initialize Graph

Check if graph exists:

bash
if [ -f ".agent/knowledge/graph.json" ]; then
  echo "Graph exists"
else
  echo "No graph found, will initialize"
fi

Initialize if not exists:

bash
PLUGIN_DIR="${CLAUDE_PLUGIN_ROOT:-$(cat "${NAVIGATOR_CONFIG_HOME:-${XDG_CONFIG_HOME:-$HOME/.config}/navigator}/plugin-root" 2>/dev/null)}"
[ -d "$PLUGIN_DIR/skills" ] || PLUGIN_DIR="$HOME/.claude/plugins/marketplaces/navigator-marketplace"
python3 "$PLUGIN_DIR/skills/nav-graph/functions/graph_builder.py" \
  --agent-dir .agent \
  --output .agent/knowledge/graph.json
Step 3A: Query Knowledge (If QUERY Action)

Extract concept from user input:

User: "What do we know about testing?"
→ Concept: testing

User: "Any pitfalls for auth?"
→ Concept: auth (normalized to authentication)

Run query:

bash
PLUGIN_DIR="${CLAUDE_PLUGIN_ROOT:-$(cat "${NAVIGATOR_CONFIG_HOME:-${XDG_CONFIG_HOME:-$HOME/.config}/navigator}/plugin-root" 2>/dev/null)}"
[ -d "$PLUGIN_DIR/skills" ] || PLUGIN_DIR="$HOME/.claude/plugins/marketplaces/navigator-marketplace"
python3 "$PLUGIN_DIR/skills/nav-graph/functions/graph_manager.py" \
  --action query \
  --concept "testing" \
  --graph-path .agent/knowledge/graph.json

Display results:

Knowledge Graph: "testing"

TASKS (3)
  - TASK-30: Task Verification Enhancement (completed)
  - TASK-17: Visual Regression Integration (completed)
  - TASK-11: Project Skills Generation (completed)

MEMORIES (2)
  - PITFALL: "Auth changes break session tests" (90%)
  - PATTERN: "Always run unit tests before integration" (85%)

SOPs (1)
  - visual-regression-setup

FILES (5)
  - skills/backend-test/*
  - skills/frontend-test/*

Load details: "Read TASK-30" or "Show testing memories"
Step 3B: Capture Memory (If CAPTURE Action)

Parse memory from user input:

User: "Remember this pitfall: auth changes often break session tests"
→ Type: pitfall
→ Summary: "auth changes often break session tests"
→ Concepts: [auth, testing]

User: "Remember we decided to use JWT over sessions for scaling"
→ Type: decision
→ Summary: "use JWT over sessions for scaling"
→ Concepts: [auth, architecture]

Determine memory type:

User SaysMemory Type
"pattern", "we use", "approach"pattern
"pitfall", "watch out", "careful"pitfall
"decided", "chose", "because"decision
"learned", "discovered", "realized"learning

Create memory:

bash
PLUGIN_DIR="${CLAUDE_PLUGIN_ROOT:-$(cat "${NAVIGATOR_CONFIG_HOME:-${XDG_CONFIG_HOME:-$HOME/.config}/navigator}/plugin-root" 2>/dev/null)}"
[ -d "$PLUGIN_DIR/skills" ] || PLUGIN_DIR="$HOME/.claude/plugins/marketplaces/navigator-marketplace"
python3 "$PLUGIN_DIR/skills/nav-graph/functions/graph_manager.py" \
  --action add-memory \
  --memory-type pitfall \
  --summary "auth changes often break session tests" \
  --concepts "auth,testing" \
  --confidence 0.9 \
  --graph-path .agent/knowledge/graph.json

Write guarantees (v6.17.0+): the backing .md is written BEFORE the graph node and failures fail loudly (no more path-points-at-nothing nodes); a failed graph save rolls the file back. Concepts are validated against the graph's concept vocabulary — an unknown concept rejects the write and lists the valid vocabulary. Pass --allow-new-concept to register genuinely new concepts instead. Graphs without a curated vocabulary skip validation.

Decisions may carry a TRIZ contradiction (TASK-72). When a decision resolved a real tension (improving A worsened B), record it so future sessions can ask "how did we resolve this kind of problem before":

bash
python3 "$PLUGIN_DIR/skills/nav-graph/functions/graph_manager.py" \
  --action add-memory --memory-type decision \
  --summary "ship new blocking features OFF by default" \
  --concepts "release,configuration" --confidence 0.95 \
  --contradiction "feature value vs regression risk" \
  --separation condition \
  --principle "dynamization (config toggle)"

All three flags are optional and free text; keep --contradiction under ~60 chars ("A vs B") because it is appended to recall lines. Separation modes (which TRIZ move resolved it):

SeparationMeaningSoftware example
timeA now, B laterre-export shims for one major, delete next (mem-063)
spaceA here, B theresingle redacting emitter module; ops never print (mem-065)
conditionA when X, B otherwiseconfirm + dry-run only on high-stakes dispatch (mem-043)
levelA at part level, B at system levelatomic tmp+rename state file over per-op writes (mem-064)

Query by contradiction (every filter word must match, case-insensitive, across contradiction + summary + principle; always exits 0):

bash
python3 "$PLUGIN_DIR/skills/nav-graph/functions/graph_manager.py" \
  --action contradictions --filter "rollback"
# Contradictions "rollback" (2)
#   - DECISION: "..." (95%) ↔ clean codebase vs rollback safety [separation: time]
#       principle: prior counter-action

Tagged memories also render with a ↔ A vs B suffix in session-start and nav-brief recall. Hand-tagging an existing decision = append the three footer lines after **Concepts**: in its .md, then graph_maintenance.py --action reconcile --execute --fields-only (see Reconcile below; --fields-only keeps a pruned resolved/ archive from being re-registered under fresh ids).

Optionally create detailed memory file:

markdown
# Pitfall: Auth Changes Break Session Tests

## Summary
Auth changes often break session tests due to...

## Context
Discovered during TASK-XX when...

## Recommended Approach
When modifying auth, always run...

## Related
- TASK-12: V3 Skills-Only
- SOP: autonomous-completion

Confirm capture:

Memory captured: mem-001

Type: Pitfall
Summary: "auth changes often break session tests"
Concepts: auth, testing
Confidence: 90%

This will be surfaced when working on auth or testing topics.
Step 3C: Initialize Graph (If INIT Action)

Build from existing docs:

bash
PLUGIN_DIR="${CLAUDE_PLUGIN_ROOT:-$(cat "${NAVIGATOR_CONFIG_HOME:-${XDG_CONFIG_HOME:-$HOME/.config}/navigator}/plugin-root" 2>/dev/null)}"
[ -d "$PLUGIN_DIR/skills" ] || PLUGIN_DIR="$HOME/.claude/plugins/marketplaces/navigator-marketplace"
python3 "$PLUGIN_DIR/skills/nav-graph/functions/graph_builder.py" \
  --agent-dir .agent \
  --output .agent/knowledge/graph.json

Display results:

Knowledge Graph Initialized

Scanned:
  - Tasks: 35
  - SOPs: 12
  - System docs: 3
  - Markers: 8

Extracted:
  - Concepts: 15
  - Relationships: 47

Graph saved to .agent/knowledge/graph.json

Query with: "What do we know about [topic]?"

Rebuild safety (v6.17.0+): re-running the builder over an existing graph PRESERVES the memories and files buckets and their edges — memories carry graph-only fields no scan can reconstruct, and rebuilds used to wipe them silently. Pass --no-preserve-memories for an intentional from-scratch rebuild.

Step 3D: Show Stats (If STATS Action)

Display graph statistics:

bash
PLUGIN_DIR="${CLAUDE_PLUGIN_ROOT:-$(cat "${NAVIGATOR_CONFIG_HOME:-${XDG_CONFIG_HOME:-$HOME/.config}/navigator}/plugin-root" 2>/dev/null)}"
[ -d "$PLUGIN_DIR/skills" ] || PLUGIN_DIR="$HOME/.claude/plugins/marketplaces/navigator-marketplace"
python3 "$PLUGIN_DIR/skills/nav-graph/functions/graph_manager.py" \
  --action stats \
  --graph-path .agent/knowledge/graph.json

Output:

Knowledge Graph Statistics
==========================
Total Nodes: 65
Total Edges: 47
Memories: 5
Last Updated: 2025-01-23T10:30:00Z

By Type:
  Tasks: 35
  SOPs: 12
  System: 3
  Markers: 8
  Concepts: 15
  Memories: 5

If user asks for related items:

User: "What's related to TASK-29?"

Run traversal:

bash
PLUGIN_DIR="${CLAUDE_PLUGIN_ROOT:-$(cat "${NAVIGATOR_CONFIG_HOME:-${XDG_CONFIG_HOME:-$HOME/.config}/navigator}/plugin-root" 2>/dev/null)}"
[ -d "$PLUGIN_DIR/skills" ] || PLUGIN_DIR="$HOME/.claude/plugins/marketplaces/navigator-marketplace"
python3 "$PLUGIN_DIR/skills/nav-graph/functions/graph_manager.py" \
  --action related \
  --node-id "TASK-29" \
  --max-depth 2 \
  --graph-path .agent/knowledge/graph.json

Memory Types

Pattern

"We use X for Y in this project"

  • Reusable approaches
  • Project conventions
  • Best practices
Pitfall

"Watch out for X when touching Y"

  • Common mistakes
  • Gotchas
  • Failure modes
Decision

"We chose X over Y because Z"

  • Architecture decisions
  • Technology choices
  • Trade-off rationale
Learning

"X usually means Y in this codebase"

  • Project-specific knowledge
  • Error interpretations
  • Domain insights

Confidence System

Base confidence:

  • Correction-based: 0.8
  • Explicit capture: 0.9

Decay:

  • 1% per week since last validation

Boost:

  • +5% per use (max +25%)

Threshold:

  • Below 0.3: Candidate for pruning
  • Above 0.7: Reliable memory

Integration with Other Skills

nav-start (Session Start)

Loads graph stats on session start:

Knowledge graph: 65 nodes, 5 memories
Relevant: 2 memories for current context
nav-task (Task Creation)

Auto-extracts concepts from new tasks:

Creating TASK-35: Project Memory
Extracted concepts: knowledge, memory, graph
Added to graph.
nav-profile (Corrections)

Corrections auto-create memories via correction_to_memory.py:

bash
PLUGIN_DIR="${CLAUDE_PLUGIN_ROOT:-$(cat "${NAVIGATOR_CONFIG_HOME:-${XDG_CONFIG_HOME:-$HOME/.config}/navigator}/plugin-root" 2>/dev/null)}"
[ -d "$PLUGIN_DIR/skills" ] || PLUGIN_DIR="$HOME/.claude/plugins/marketplaces/navigator-marketplace"
# When correction detected in nav-profile:
python3 "$PLUGIN_DIR/skills/nav-graph/functions/correction_to_memory.py" \
  --action convert-one \
  --correction-json '{"pattern": "...", "context": "...", "confidence": "high"}'

# Output:
[Correction detected]
→ Type: pitfall (based on pattern analysis)
→ Concepts: [auth, testing] (auto-extracted)
→ Created memory: mem-002
→ Added to graph

Sync all corrections:

bash
PLUGIN_DIR="${CLAUDE_PLUGIN_ROOT:-$(cat "${NAVIGATOR_CONFIG_HOME:-${XDG_CONFIG_HOME:-$HOME/.config}/navigator}/plugin-root" 2>/dev/null)}"
[ -d "$PLUGIN_DIR/skills" ] || PLUGIN_DIR="$HOME/.claude/plugins/marketplaces/navigator-marketplace"
python3 "$PLUGIN_DIR/skills/nav-graph/functions/correction_to_memory.py" \
  --action sync \
  --profile-path .agent/.user-profile.json \
  --graph-path .agent/knowledge/graph.json
nav-marker (Context Markers)

Markers reference graph state:

## Graph State
- Memories surfaced: mem-001, mem-003
- Concepts active: auth, testing
navigator-research (Codebase Exploration Agent)

The navigator-research agent emits a structured research_findings JSON block alongside its markdown summary. After the agent returns, ingest those findings as graph memories via research_to_graph.py:

bash
PLUGIN_DIR="${CLAUDE_PLUGIN_ROOT:-$(cat "${NAVIGATOR_CONFIG_HOME:-${XDG_CONFIG_HOME:-$HOME/.config}/navigator}/plugin-root" 2>/dev/null)}"
[ -d "$PLUGIN_DIR/skills" ] || PLUGIN_DIR="$HOME/.claude/plugins/marketplaces/navigator-marketplace"
# Save the JSON block from the agent output to a file (or pipe via stdin)
python3 "$PLUGIN_DIR/skills/nav-graph/functions/research_to_graph.py" findings.json

# Or from stdin
cat findings.json | python3 "$PLUGIN_DIR/skills/nav-graph/functions/research_to_graph.py" -

# Validate without writing
python3 "$PLUGIN_DIR/skills/nav-graph/functions/research_to_graph.py" findings.json --dry-run

Trigger phrases:

  • "Ingest research findings"
  • "Save these findings to the graph"
  • (Automatic, when a navigator-research invocation completes — orchestrator may auto-ingest)

Defaults:

  • Confidence: 0.7 (lower than corrections/explicit captures — research is inference)
  • Memory types accepted: pattern, pitfall, decision, learning
  • Invalid entries are skipped with a printed error (exit code 1 if any errors)
  • Evidence path (e.g. src/auth.ts:42) is embedded into the memory summary

Schema: see the Output Format section of agents/navigator-research.md for the full JSON shape the agent emits.

nav-deep-research (Web Research Skill)

Web research runs (skills/nav-deep-research) ingest through the same path: after the ship gate passes, report_to_graph.py --run <slug> turns every typed ## Key findings bullet of the report into a memory whose evidence is the cited source URL(s), then calls research_to_graph.ingest_findings. Same 0.7 confidence and memory types; no schema change.


Configuration

In .agent/.nav-config.json:

json
{
  "knowledge_graph": {
    "enabled": true,
    "auto_capture_corrections": true,
    "auto_capture_decisions": true,
    "auto_surface_relevant": true,
    "max_session_memories": 5,
    "confidence_decay_rate": 0.01,
    "staleness_threshold_days": 90,
    "git_tracked": true
  }
}

Note: confidence_decay_rate and staleness_threshold_days are consumed only by the manual graph_maintenance commands (--action decay / --action stale). They are not applied automatically on session start — decaying a git-tracked file every session would create constant churn. Run decay/staleness manually when curating the graph.


Show full SKILL.md (564 more words)Show less

Graph Maintenance

Health Check
bash
PLUGIN_DIR="${CLAUDE_PLUGIN_ROOT:-$(cat "${NAVIGATOR_CONFIG_HOME:-${XDG_CONFIG_HOME:-$HOME/.config}/navigator}/plugin-root" 2>/dev/null)}"
[ -d "$PLUGIN_DIR/skills" ] || PLUGIN_DIR="$HOME/.claude/plugins/marketplaces/navigator-marketplace"
python3 "$PLUGIN_DIR/skills/nav-graph/functions/graph_maintenance.py" --action health

Output:

Knowledge Graph Health Check
========================================
Total Nodes: 133
Total Edges: 706
Memories: 37 (37 high confidence)
Tasks: 38
Concepts: 16
Orphan Nodes: 0
Duplicate Edges: 0
Dangling Edges: 0
Confidence Out-of-Range: 0

Health Score: 100/100

No integrity issues detected!

Advisory (not scored):
  - 8 potential memory conflicts (heuristic, advisory)
  - 3 stale memories (not validated in 90+ days)

Duplicate Edges, Dangling Edges, and Confidence Out-of-Range are the integrity gate — all three should read 0 on a healthy graph. If they don't, run --action repair (below).

v6.17.0 adds disk-vs-graph checks: Broken File Links (node references a file that doesn't exist) and Unindexed Memory Files (files on disk with no node — the drift class a 2026-07 audit found at 52/84 in a consumer repo) are score-affecting; concept-vocabulary drift and archived resolved/ files without nodes are advisory. Pass --root <project-root> when running from another directory.

Reconcile Disk vs Graph (v6.17.0+)

Report drift between memory files on disk and graph nodes; --execute registers unindexed files (type from parent dir, resolved/ parent → resolved: true, frontmatter/heading parsing with conservative fallbacks — 0.5 confidence when unknown) and copies TRIZ footer fields (**Contradiction** / **Separation** / **Principle**, TASK-72) from disk onto already-indexed nodes (reported as field_updates; never clears a field removed on disk, never re-syncs summary). Broken-link nodes are never auto-deleted and concept refs are never rewritten — those two are report-and-hint only:

bash
PLUGIN_DIR="${CLAUDE_PLUGIN_ROOT:-$(cat "${NAVIGATOR_CONFIG_HOME:-${XDG_CONFIG_HOME:-$HOME/.config}/navigator}/plugin-root" 2>/dev/null)}"
[ -d "$PLUGIN_DIR/skills" ] || PLUGIN_DIR="$HOME/.claude/plugins/marketplaces/navigator-marketplace"
# Dry-run report
python3 "$PLUGIN_DIR/skills/nav-graph/functions/graph_maintenance.py" --action reconcile
# Register unindexed files + apply TRIZ field updates
python3 "$PLUGIN_DIR/skills/nav-graph/functions/graph_maintenance.py" --action reconcile --execute
# TRIZ field updates only (safe when resolved/ holds deliberately pruned files)
python3 "$PLUGIN_DIR/skills/nav-graph/functions/graph_maintenance.py" --action reconcile --execute --fields-only
Resolve / Supersede a Memory (v6.17.0+)

When a memory stops being true (bug fixed, decision reversed, guidance codified elsewhere), do NOT delete it — resolve it. The node gets resolved: true (+ superseded_by and a supersedes edge when a newer memory replaces it) and the backing file moves to the sibling resolved/ directory. Resolved memories are excluded from session-start surfacing and task-doc recall, skipped by stale/decay sweeps, and flagged [resolved] in query output:

bash
python3 "$PLUGIN_DIR/skills/nav-graph/functions/graph_manager.py" \
  --action resolve-memory --node-id mem-012 [--superseded-by mem-045]
Memory Recall (v6.17.0+)

Deterministic relevance ranking used by the SessionStart hook and nav-task Step 2.5 — also useful standalone:

bash
# Explicit concepts (markdown for task docs, compact for terse output)
python3 "$PLUGIN_DIR/skills/nav-graph/functions/memory_recall.py" \
  --concepts "auth,testing" --format markdown --limit 5
# Auto mode: concepts from open task nodes + active context marker
python3 "$PLUGIN_DIR/skills/nav-graph/functions/memory_recall.py" \
  --auto --agent-dir .agent --limit 5

Scoring: concept overlap (alias-resolved), then confidence; resolved memories excluded; silent (exit 0, no output) when nothing matches. Compatible with consumer graphs that use file: keys and lack a concept_index.

Repair Integrity Defects

Idempotently dedupe (from, to, type) edge rows, drop edges that reference a missing node id, and normalize out-of-range memory confidences (a value like 90.0 is treated as 90% → 0.9). Safe to re-run:

bash
PLUGIN_DIR="${CLAUDE_PLUGIN_ROOT:-$(cat "${NAVIGATOR_CONFIG_HOME:-${XDG_CONFIG_HOME:-$HOME/.config}/navigator}/plugin-root" 2>/dev/null)}"
[ -d "$PLUGIN_DIR/skills" ] || PLUGIN_DIR="$HOME/.claude/plugins/marketplaces/navigator-marketplace"
python3 "$PLUGIN_DIR/skills/nav-graph/functions/graph_maintenance.py" --action repair
Conflict Detection

Find memories that may contradict each other. Advisory only — a high-false-positive keyword heuristic that does not affect the health score:

bash
PLUGIN_DIR="${CLAUDE_PLUGIN_ROOT:-$(cat "${NAVIGATOR_CONFIG_HOME:-${XDG_CONFIG_HOME:-$HOME/.config}/navigator}/plugin-root" 2>/dev/null)}"
[ -d "$PLUGIN_DIR/skills" ] || PLUGIN_DIR="$HOME/.claude/plugins/marketplaces/navigator-marketplace"
python3 "$PLUGIN_DIR/skills/nav-graph/functions/graph_maintenance.py" --action conflicts
Stale Memory Detection

Find memories not validated in 90+ days:

bash
PLUGIN_DIR="${CLAUDE_PLUGIN_ROOT:-$(cat "${NAVIGATOR_CONFIG_HOME:-${XDG_CONFIG_HOME:-$HOME/.config}/navigator}/plugin-root" 2>/dev/null)}"
[ -d "$PLUGIN_DIR/skills" ] || PLUGIN_DIR="$HOME/.claude/plugins/marketplaces/navigator-marketplace"
python3 "$PLUGIN_DIR/skills/nav-graph/functions/graph_maintenance.py" --action stale --stale-days 90
Low Confidence Pruning

Find and optionally remove low-confidence memories:

bash
PLUGIN_DIR="${CLAUDE_PLUGIN_ROOT:-$(cat "${NAVIGATOR_CONFIG_HOME:-${XDG_CONFIG_HOME:-$HOME/.config}/navigator}/plugin-root" 2>/dev/null)}"
[ -d "$PLUGIN_DIR/skills" ] || PLUGIN_DIR="$HOME/.claude/plugins/marketplaces/navigator-marketplace"
# Preview what would be removed
python3 "$PLUGIN_DIR/skills/nav-graph/functions/graph_maintenance.py" --action prune --threshold 0.3 --dry-run

# Actually remove (use with caution)
python3 "$PLUGIN_DIR/skills/nav-graph/functions/graph_maintenance.py" --action prune --threshold 0.3 --execute
Apply Decay (experimental, manual-only)

Reduce confidence based on time since each memory's last decay. Idempotent — running it twice on the same day is a no-op (each memory tracks last_decayed). The rate defaults to knowledge_graph.confidence_decay_rate when --decay-rate is omitted. This is not wired to any hook; run it manually when curating:

bash
PLUGIN_DIR="${CLAUDE_PLUGIN_ROOT:-$(cat "${NAVIGATOR_CONFIG_HOME:-${XDG_CONFIG_HOME:-$HOME/.config}/navigator}/plugin-root" 2>/dev/null)}"
[ -d "$PLUGIN_DIR/skills" ] || PLUGIN_DIR="$HOME/.claude/plugins/marketplaces/navigator-marketplace"
python3 "$PLUGIN_DIR/skills/nav-graph/functions/graph_maintenance.py" --action decay

Token Budget

ComponentTokensWhen
graph.json (50 nodes)~1000On query
graph.json (200 nodes)~2000On query
Memory summaries (5)~500On session start
Full memory detail~500 eachOn request

Session overhead: ~1.3k tokens


Success Criteria

Graph skill succeeds when:

  • Query returns relevant results across knowledge types
  • Memories persist and are surfaced appropriately
  • Concepts connect related items
  • Confidence decay/boost works
  • Graph stays under 2k tokens overhead

Best Practices

Good queries:

  • "What do we know about auth?" (specific concept)
  • "Any pitfalls for testing?" (scoped type)
  • "Show everything related to TASK-29" (node traversal)

Good memory capture:

  • "Remember: we use X for Y" (clear pattern)
  • "Remember this pitfall: X breaks Y" (specific issue)
  • "Remember we decided X because Y" (rationale included)

Avoid:

  • Overly broad queries ("What do we know?")
  • Storing code snippets in memories (use paths instead)
  • Capturing obvious knowledge (focus on project-specific insights)

This skill transforms Navigator from stateless assistant to knowledge-aware team member

© qf-studio, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

SKILL.md and 17 other files in skills/nav-graph of qf-studio/navigator.

  • SKILL.md
  • functions/correction_to_memory.py
  • functions/execution_to_graph.py
  • functions/graph_builder.py
  • functions/graph_maintenance.py
  • functions/graph_manager.py
  • functions/memory_recall.py
  • functions/memory_writer.py
  • functions/research_to_graph.py
  • functions/task_to_graph.py
  • functions/test_correction_to_memory.py
  • functions/test_graph_builder.py
  • functions/test_graph_maintenance.py
  • functions/test_graph_manager.py
  • functions/test_memory_recall.py
  • functions/test_memory_writer.py
  • functions/test_task_to_graph.py
  • templates/memory-template.md

Open the folder on GitHubat commit 3bb9eac

Compare with similar skills

Nav Graph next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Nav Graph compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Nav Graph this skillqf-studio/navigator355—~5.9kAutomated safety check: NotesMIT
Obsidian Canvas BoardsAgriciDaniel/claude-obsidian15k—~1.4kAutomated safety check: PassMIT
Ontology1mancompany/OneManCompany4422 repos~1.5kAutomated safety check: PassApache-2.0
Knowledge Graphgnomeria/usbtree691—~1.5kAutomated safety check: PassMIT
Graphagenticnotetaking/arscontexta3.5k—~4.9kAutomated safety check: NotesMIT
LLM Wiki Knowledge GraphEgonex-AI/Understand-Anything86k—~1.5kAutomated safety check: PassMIT

Similar skills

  • Obsidian Canvas Boards

    AgriciDaniel/claude-obsidian

    Creates, inspects and updates Obsidian JSON Canvas boards in a vault, with text, file, link, group and edge nodes, using safe recoverable edits.

    15k GitHub stars~1.4k tokensUpdated 29 days ago
    Knowledge ManagementAuto-check passed
  • Ontology

    1mancompany/OneManCompany

    Typed knowledge graph for structured agent memory and composable skills.

    442 GitHub starsUsed in 2 repos~1.5k tokens
    Knowledge ManagementAuto-check passed
  • Knowledge Graph

    gnomeria/usbtree

    Set up and maintain a lightweight, file-based knowledge graph of the repo — entities, typed relations, decisions, gotchas — so agents load context fast instead of re-exploring the codebase every…

    691 GitHub stars~1.5k tokensUpdated 1 mo ago
    Knowledge ManagementAuto-check passed
  • Graph

    agenticnotetaking/arscontexta

    Interactive knowledge graph analysis. An agent skill from agenticnotetaking/arscontexta.

    3.5k GitHub stars~4.9k tokensUpdated 7 mo ago
    Knowledge ManagementAuto-check: notes
  • LLM Wiki Knowledge Graph

    Egonex-AI/Understand-Anything

    Detects a Karpathy-pattern LLM wiki and builds an interactive knowledge graph with entities, implicit relationships and topic clusters.

    86k GitHub stars~1.5k tokensUpdated yesterday
    Knowledge ManagementAuto-check passed
  • Gitnexus Guide

    aws-samples/sample-kolya-br-proxy

    Official

    A skill your agent uses when the user asks about GitNexus itself — available tools, how to query the knowledge graph, MCP resources, graph schema, or workflow reference.

    106 GitHub starsUsed in 11 repos~867 tokens
    Knowledge ManagementAuto-check passed

More from qf-studio/navigator

All 32 skills in this repo
  • Nav Start

    qf-studio/navigator

    Load Navigator documentation navigator when starting development session, resuming work, or beginning new feature.

    355 GitHub stars~4.7k tokensUpdated yesterday
    Auto-check: notes
  • Backend Endpoint

    qf-studio/navigator

    Create REST/GraphQL API endpoint with validation, error handling, and tests.

    355 GitHub stars~4.5k tokensUpdated yesterday
    Auto-check: notes
  • Backend Test

    qf-studio/navigator

    Generate backend tests (unit, integration, mocks) for existing code.

    355 GitHub stars~1.5k tokensUpdated yesterday
    Auto-check: notes
  • Database Migration

    qf-studio/navigator

    Create database migration with schema changes and rollback. An agent skill from qf-studio/navigator.

    355 GitHub stars~3.7k tokensUpdated yesterday
    Auto-check: notes
  • Frontend Component

    qf-studio/navigator

    Create React/Vue component with TypeScript, tests, and styles.

    355 GitHub stars~4.5k tokensUpdated yesterday
    Auto-check: notes
  • Frontend Test

    qf-studio/navigator

    Generate frontend component tests (React Testing Library, Vue Test Utils, snapshot) for existing components.

    355 GitHub stars~1.6k tokensUpdated yesterday
    Auto-check: notes

Questions about Nav Graph

What does Nav Graph do?

Query project knowledge graph. An agent skill from qf-studio/navigator. Nav Graph is an agent skill from qf-studio/navigator. Query project knowledge graph.

When should I use Nav Graph?

Nav Graph fits situations like: user asks what do we know about X?; show everything related to X; remember this pattern/pitfall/decision.

How do I install Nav Graph in Claude Code?

Run `npx skills add qf-studio/navigator --skill nav-graph -a claude-code`. Or copy the skill folder (skills/nav-graph in qf-studio/navigator) into .claude/skills/nav-graph in your project. Claude Code loads it when a task matches its description.

How do I install Nav Graph in Codex?

Run `npx skills add qf-studio/navigator --skill nav-graph -a codex`. Or copy the skill folder (skills/nav-graph in qf-studio/navigator) into .agents/skills/nav-graph in your project. Codex loads it when a task matches its description.

Can I use Nav Graph in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add qf-studio/navigator --skill nav-graph -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/nav-graph, .gemini/skills/nav-graph, .github/skills/nav-graph and .opencode/skills/nav-graph in your project.

What does Nav Graph need to run?

Going by SKILL.md and its folder, Nav Graph needs Python for the scripts in its folder and the command-line tools its instructions call (python3). Our summary lists: Python 3. Its frontmatter pre-approves these tools: Read, Write, Edit, Bash.

Does Nav Graph access the network?

SKILL.md contains no URLs. Any network use would come from the scripts or tools the agent runs. This is read from the text; nothing was executed.

Is Nav Graph safe to install?

Our automated static check of SKILL.md found notes only (pre-approves every shell command (allowed-tools: bash)), nothing it rates as a warning. It is not a guarantee. Review the folder before installing.

What licence does Nav Graph use?

Nav Graph is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Nav Graph use?

About 5.9k tokens (SKILL.md is roughly 23k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to Nav Graph?

Skills that share tags, products or a category with Nav Graph: Obsidian Canvas Boards (AgriciDaniel/claude-obsidian, 15k stars), Ontology (1mancompany/OneManCompany, 442 stars), Knowledge Graph (gnomeria/usbtree, 691 stars) and Graph (agenticnotetaking/arscontexta, 3.5k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Nav Graph?

qf-studio (a GitHub organization) maintains it in qf-studio/navigator, which has 355 GitHub stars. The repository holds 32 skills in this directory. The repository was last updated on October 8, 2026.

Source: qf-studio/navigator on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.