Agent skill

Nav Start

by qf-studio in qf-studio/navigator

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

MITAuto-check: notesAgent Workflows

Install Nav Start

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

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

GitHub CLI
$ gh skill install qf-studio/navigator nav-start --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-start .claude/skills/nav-start && 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-start
GitHub stars
355
Token cost
~4.7k tokens
SKILL.md length
1,239 words
Files
5 (incl. scripts)
Skills in repo
32
Repo updated
First seen
Licence
MIT

At a glance

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

  • Works in 12 steps: Detect SessionStart Hook Injection (Fast… → Check Navigator Version → 5: Auto-Update (if enabled) → …
  • User mentions starting work
  • SKILL.md covers When to Invoke, Execution Steps, Reference Files and Error Handling, plus 2 more sections
  • Runs Python scripts from its folder; calls python3, bash and gh

What it does

Nav Start is an agent skill from qf-studio/navigator. Load Navigator documentation navigator when starting development session, resuming work, or beginning new feature. Use when user mentions starting work, beginning session, resuming after break, or checking project status.

Its SKILL.md is about 4.7k tokens, which your agent loads only when the skill is triggered. The skill folder holds 6 other files, including scripts (for example `functions/auto_updater.py`, `functions/test_auto_updater.py` and `functions/test_workflow_detector.py`).

It sits in Agent Workflows. 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 mentions starting work
  • Beginning session
  • Resuming after break
  • Checking project status

Example prompts

  • “/nav-start”

Requirements

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

Workflow steps

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

  1. Detect SessionStart Hook Injection (Fast Path) [v6.9.0+]
  2. Check Navigator Version
  3. 5: Auto-Update (if enabled)
  4. Check Navigator Initialization
  5. Load Documentation Navigator
  6. Check for Active Context Marker
  7. Load Navigator Configuration
  8. 1: Check Version Drift
  9. 5: Load Knowledge Graph (v6.0.0+) [EXECUTE]
  10. 6: Load User Profile (ToM - Bilateral Modeling) [EXECUTE]
  11. Check PM Tool for Assigned Tasks
  12. Display Session Statistics (OpenTelemetry)

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
    • Bash

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Ships 1 file in scripts/ (Python), which the agent can run.

    Shell commands in SKILL.md call:

    • python3
    • bash
    • gh
    • claude

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

  • Network

    No URLs in SKILL.md. Its commands use gh, which can reach the network depending on how they are called.

    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 Start loads about 4.7k tokens when it runs. Until then it costs about 58 tokens; SKILL.md has 1,239 words of instructions outside code blocks.

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

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, 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); the scripts in this folder are not scanned.

SKILL.md

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

Download SKILL.mdSave it as .claude/skills/nav-start/SKILL.md (or your agent's skills folder). This skill also uses 4 other files; get the full folder from GitHub.
name
nav-start
description
Load Navigator documentation navigator when starting development session, resuming work, or beginning new feature. Use when user mentions starting work, beginning session, resuming after break, or checking project status.
allowed-tools
Read, Bash
version
1.0.0

Navigator Navigator Skill

Load the Navigator documentation navigator to start your development session with optimized context.

When to Invoke

Invoke this skill when the user:

  • Says "start my session", "begin work", "start working"
  • Says "load the navigator", "show me the docs"
  • Asks "what should I work on?"
  • Mentions "resume work", "continue from where I left off"
  • Asks about project structure or current tasks

DO NOT invoke if:

  • User already ran /nav:start command this conversation
  • Navigator already loaded (check conversation history)
  • User is in middle of implementation (only invoke at session start)

Execution Steps

Step 0: Detect SessionStart Hook Injection (Fast Path) [v6.9.0+]

Before doing anything else, check whether the SessionStart hook has already injected Navigator context into this session. The hook emits a sentinel string on success:

<!-- nav-session-start-injected:v1 -->

If the sentinel is present in your system context (it appears inside a SessionStart system reminder block at the very top of the conversation):

→ Fast path activated. Do NOT execute Steps 1–7. The data those steps would Read is already in your context window. Skip directly to Step 8 (Display Session Summary) and render it using the injected data.

This eliminates ~6 Read tool invocations per session start and saves ~1.5-2k tokens of tool-call ceremony. The user-visible output must be byte-identical to the legacy path — they should not be able to tell which mode produced it.

If the sentinel is absent (legacy project without the hook, hook disabled in .agent/.nav-config.json, or hook crashed):

→ Legacy path. Execute Steps 1–7 as documented below. Same behavior as pre-v6.9.0.

Detection rule of thumb: If you can read the string nav-session-start-injected anywhere in the system reminders that opened this conversation, you are on the fast path.


Step 1: Check Navigator Version

Check if user is running latest Navigator version:

bash
# Run version checker (optional - doesn't block session start)
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"
if [ -f "$PLUGIN_DIR/scripts/check-version.sh" ]; then
  bash "$PLUGIN_DIR/scripts/check-version.sh"

  # Note: Exit code 1 means update available, but don't block session
  # Exit code 0 means up to date
  # Exit code 2 means cannot check (network issue)
fi

Version check behavior:

  • If update available: Show notification, continue session
  • If up to date: Show ✅, continue session
  • If cannot check: Skip silently, continue session

Never block session start due to version check.

Step 1.5: Auto-Update (if enabled)

Run exactly this one command. It reads auto_update from the project config, checks the latest release, and updates the plugin only when one is available. It prints one JSON object.

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-start/functions/auto_updater.py"

Report only what that JSON says. Never write an update line from memory or a template:

  • "status": "updated" → ✅ Navigator updated from <current_version> to <new_version>. Restart Claude Code to load it. (values copied from the JSON)
  • "status": "failed" → ⚠️ <message>. Update by hand: claude plugin update navigator@navigator-marketplace
  • "up-to-date", "disabled", "skipped", or the command did not run → say nothing about updates

Since v8 the Navigator mod also shows a read-only toast at session start when a newer release exists (TASK-81). It never updates by itself; this step and claude plugin update do.

Never block session start because of this step.

Step 2: Check Navigator Initialization

Check if .agent/DEVELOPMENT-README.md exists:

bash
if [ ! -f ".agent/DEVELOPMENT-README.md" ]; then
  echo "❌ Navigator not initialized in this project"
  echo ""
  echo "Run /nav:init to set up Navigator structure first."
  exit 1
fi

If not found, inform user to run /nav:init first.

Step 3: Load Documentation Navigator

Read the navigator file:

Read(
  file_path: ".agent/DEVELOPMENT-README.md"
)

This is the lightweight index (~2k tokens) that tells you:

  • What documentation exists
  • When to load specific docs
  • Current task focus
  • Project structure overview
Step 4: Check for Active Context Marker

Check if there's an active marker from previous /nav:compact:

bash
if [ -f ".agent/.context-markers/.active" ]; then
  marker_file=$(cat .agent/.context-markers/.active)
  echo "🔄 Active context marker detected!"
  echo ""
  echo "Marker: $marker_file"
  echo ""
  echo "This marker was saved during your last /nav:compact."
  echo "Load it to continue where you left off?"
  echo ""
  echo "[Y/n]:"
fi

If user confirms (Y or Enter):

  • Read the marker file: Read(file_path: ".agent/.context-markers/{marker_file}")
  • Delete .active file: rm .agent/.context-markers/.active
  • Show confirmation: "✅ Context restored from marker!"

If user declines (n):

  • Delete .active file
  • Show: "Skipping marker load. You can load it later with /nav:markers"
Step 5: Load Navigator Configuration

Read configuration:

Read(
  file_path: ".agent/.nav-config.json"
)

Parse:

  • project_management: Which PM tool (linear, github, jira, none)
  • task_prefix: Task ID format (TASK, GH, LIN, etc.)
  • team_chat: Team notifications (slack, discord, none)
  • tom_features: ToM configuration (if present, v5.0.0+)
Step 5.1: Check Version Drift

Check if project config version matches plugin version:

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"
DRIFT_RESULT=$(python3 "$PLUGIN_DIR/skills/nav-start/functions/auto_updater.py" --check-drift 2>/dev/null || echo '{"has_drift": false}')
HAS_DRIFT=$(echo "$DRIFT_RESULT" | python3 -c "import sys,json; print(json.load(sys.stdin).get('has_drift', False))" 2>/dev/null)

if [ "$HAS_DRIFT" = "True" ]; then
  DRIFT_MSG=$(echo "$DRIFT_RESULT" | python3 -c "import sys,json; print(json.load(sys.stdin).get('message', ''))" 2>/dev/null)
  echo ""
  echo "⚠️  VERSION DRIFT DETECTED"
  echo "   $DRIFT_MSG"
  echo ""
fi

Version drift occurs when:

  • Plugin updated but project config wasn't synced
  • Manual plugin install without running nav-upgrade
  • Project cloned with old config version

Display warning if drift detected:

⚠️  VERSION DRIFT DETECTED
   Project config (v5.5.0) behind plugin (v5.7.0). Run "update my CLAUDE.md" to sync.

This helps users understand why skills may behave unexpectedly.

Step 5.5: Load Knowledge Graph (v6.0.0+) [EXECUTE]

Check if knowledge graph exists and is enabled:

bash
if [ -f ".agent/knowledge/graph.json" ]; then
  # Get graph stats
  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"
  GRAPH_STATS=$(python3 "$PLUGIN_DIR/skills/nav-graph/functions/graph_manager.py" --action stats --graph-path .agent/knowledge/graph.json 2>/dev/null)
  echo "$GRAPH_STATS"
fi

Display graph summary in session output:

📚 Knowledge Graph: Active
   Nodes: {total_nodes} | Memories: {memory_count}
   Concepts: {concept_count} indexed

Surface relevant memories (v6.17.0+: injected automatically): The SessionStart hook now enforces auto_surface_relevant — when the sentinel is present (fast path), a ## Relevant Memories block is already in your context, produced by memory_recall.py --auto (concepts from open task nodes + active marker, resolved memories excluded). Render it as:

💡 Relevant Memories:
   - PITFALL: "Auth changes often break session tests" (90%)
   - PATTERN: "Always run unit tests before integration" (85%)

Legacy path only (sentinel absent): run the recall CLI manually:

bash
python3 "$PLUGIN_DIR/skills/nav-graph/functions/memory_recall.py" \
  --auto --agent-dir .agent --graph-path .agent/knowledge/graph.json \
  --limit 5 --format compact

Empty output → omit the block. Disable via knowledge_graph.auto_surface_relevant: false in .agent/.nav-config.json (max_session_memories caps the count).

If graph doesn't exist:

📚 Knowledge Graph: Not initialized
   Run "Initialize knowledge graph" to enable
Show full SKILL.md (495 more words)Show less
Step 5.6: Load User Profile (ToM - Bilateral Modeling) [EXECUTE]

IMPORTANT: This step MUST be executed, not just documented.

Check if user profile exists:

bash
if [ -f ".agent/.user-profile.json" ]; then
  echo "📋 User profile found"
else
  echo "No user profile. Using defaults."
fi

If profile exists, READ IT NOW:

Read(
  file_path: ".agent/.user-profile.json"
)

After reading, APPLY these preferences for the session:

  1. Verbosity (preferences.communication.verbosity):

    • concise: Keep responses brief, code-first
    • balanced: Normal explanations (default)
    • detailed: Thorough explanations with context
  2. Confirmation threshold (preferences.communication.confirmation_threshold):

    • always: Show verification checkpoints for all skills
    • high-stakes: Only for backend-endpoint, database-migration, frontend-component (default)
    • never: Skip verification checkpoints
  3. Frameworks (preferences.technical.preferred_frameworks):

    • Remember for code generation suggestions
    • E.g., ["react", "express"] → prefer these in examples
  4. Corrections (corrections[]):

    • Review recent patterns to avoid repeating mistakes
    • E.g., "REST endpoints use plural nouns" → apply immediately

Display profile summary in session output:

🧠 Theory of Mind: Active
   Profile: Loaded ({corrections_count} corrections, {goals_count} goals)
   Verbosity: {verbosity}
   Checkpoints: {confirmation_threshold}

If profile doesn't exist:

🧠 Theory of Mind: Active (no profile yet)
   Say "save my preferences" to create one
Step 6: Check PM Tool for Assigned Tasks

If PM tool is Linear:

bash
# Check if Linear MCP available
# Try to list assigned issues

If PM tool is GitHub:

bash
gh issue list --assignee @me --limit 10 2>/dev/null

If PM tool is none: Skip task checking.

Step 7: Display Session Statistics (OpenTelemetry)

Run the OpenTelemetry session statistics script:

bash
# Resolve the installed plugin directory
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-start/scripts/otel_session_stats.py"

This script:

  • If OTel enabled: Shows real-time metrics from Claude Code
    • Real token usage (input/output/cache)
    • Cache hit rate (CLAUDE.md caching performance)
    • Session cost (actual USD spent)
    • Active time (seconds of work)
    • Context availability
  • If OTel disabled: Shows setup instructions
  • If no metrics yet: Shows "waiting for export" message

Benefits of OTel integration:

  • Real data (not file-size estimates)
  • Cache performance validation
  • Cost tracking for ROI measurement
  • Official API (won't break on updates)
Step 8: Display Session Summary

Show the Navigator ASCII logo and session summary.

Display the logo using these exact ANSI color codes:

bash
# Colors: Blue N, Red A, Blue V (Navigator arrow)
BLUE='\033[1;34m'
RED='\033[1;31m'
WHITE='\033[1;37m'
GRAY='\033[90m'
NC='\033[0m'

printf "${BLUE}███╗   ██╗${NC} ${RED} █████╗ ${NC}${BLUE}██╗   ██╗${NC}\n"
printf "${BLUE}████╗  ██║${NC} ${RED}██╔══██╗${NC}${BLUE}██║   ██║${NC}\n"
printf "${BLUE}██╔██╗ ██║${NC} ${RED}███████║${NC}${BLUE}██║   ██║${NC}  ${WHITE}v6.0.0${NC}\n"
printf "${BLUE}██║╚██╗██║${NC} ${RED}██╔══██║${NC}${BLUE}╚██╗ ██╔╝${NC}  ${GRAY}Knowledge Graph${NC}\n"
printf "${BLUE}██║ ╚████║${NC} ${RED}██║  ██║${NC}${BLUE} ╚████╔╝ ${NC}\n"
printf "${BLUE}╚═╝  ╚═══╝${NC} ${RED}╚═╝  ╚═╝${NC}${BLUE}  ╚═══╝  ${NC}\n"

Then show the session info:

📖 Navigator: Loaded
🎯 PM: [PM tool or "Manual"]
✅ Optimization: Active
🧠 ToM: [Profile status from Step 5.6]
📚 Graph: [Knowledge graph status from Step 5.5]

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

📊 DOCUMENTATION LOADED (MEASURED)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Navigator (.agent/DEVELOPMENT-README.md):
  Size: [nav_bytes] bytes = [nav_tokens] tokens

CLAUDE.md (auto-loaded):
  Size: [claude_bytes] bytes = [claude_tokens] tokens

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Total documentation:     [total_tokens] tokens
Available for work:      [available] tokens ([percent]%)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

💡 On-demand loading strategy:
   Load task doc when needed:  +3-5k tokens
   Load system doc if needed:  +4-6k tokens
   Load SOP if helpful:        +2-3k tokens

   Total with all docs:        ~[total + 15]k tokens

   vs Traditional (all upfront): ~150k tokens
   Savings: ~[150 - total - 15]k tokens

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

🔹 WORKFLOW ENFORCEMENT (MANDATORY)

Before responding to ANY task, show:
┌─────────────────────────────────────┐
│ WORKFLOW CHECK                      │
├─────────────────────────────────────┤
│ Loop trigger: [YES/NO]              │
│ Complexity: [0.X]                   │
│ Mode: [LOOP/TASK/DIRECT]            │
└─────────────────────────────────────┘

Loop triggers: "run until done", "do all", "keep going"
Task triggers: multi-file, refactor, new feature
Skipping this check = WORKFLOW VIOLATION

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

🔹 Navigator WORKFLOW REMINDER

1. Workflow enforcement
   - ✅ ALWAYS show WORKFLOW CHECK on tasks
   - Loop Mode: NAVIGATOR_STATUS each iteration
   - Task Mode: Phase tracking (RESEARCH→COMPLETE)

2. Navigator-first loading
   - ✅ Loaded: .agent/DEVELOPMENT-README.md
   - Next: Load ONLY relevant task/system docs

3. Use agents for research
   - Multi-file searches: Use Task agent (saves 60-80% tokens)
   - Code exploration: Use Explore agent

4. Context management
   - Run nav-compact skill after isolated sub-tasks
   - Context markers save your progress

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

[FIRST SESSION FEATURES DISPLAY - v5.6.0+]

Check if this is first session after install/update:

```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"
FIRST_SESSION_MARKER=".agent/.features-shown-$(cat .agent/.nav-config.json | python3 -c "import sys,json; print(json.load(sys.stdin).get('version',''))" 2>/dev/null)"

if [ ! -f "$FIRST_SESSION_MARKER" ]; then
  echo ""
  python3 "$PLUGIN_DIR/skills/nav-features/functions/feature_manager.py" show --first-session
  echo ""
  echo "💡 Toggle features: 'show my features' or 'disable loop_mode'"
  echo ""
  touch "$FIRST_SESSION_MARKER"
fi

Shows feature table on:

  • First session after Navigator install
  • First session after version update (new version = new marker)

Do NOT show if:

  • Features already shown for this version
  • feature_manager.py not found (older plugin)

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

[If tasks found from PM tool, list them here]

[If no tasks found:] No active tasks found. What would you like to work on?


## Predefined Functions

### scripts/otel_session_stats.py

**Purpose**: Display real-time session statistics via OpenTelemetry

**When to call**: After loading navigator, before presenting session summary

**Requirements**:
- CLAUDE_CODE_ENABLE_TELEMETRY=1 (optional - shows setup if disabled)
- Metrics available from current session (shows waiting message if not)

**Execution**:
```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-start/scripts/otel_session_stats.py"

Output: Formatted statistics with:

  • Token usage breakdown (input/output/cache)
  • Cache hit rate percentage
  • Session cost in USD
  • Active time
  • Context availability

Error Handling:

  • If OTel not enabled: Shows setup instructions
  • If no metrics yet: Shows "waiting for export" message
  • Never crashes - always displays helpful guidance

Reference Files

This skill uses:

  • otel_session_stats.py: Real-time session stats via OpenTelemetry
  • .agent/DEVELOPMENT-README.md: Navigator content
  • .agent/.nav-config.json: Configuration
  • .agent/.context-markers/.active: Active marker check

Fast-path source (v6.9.0+): the SessionStart op at hooks/ops/session_start.py (dispatched by hooks/nav_dispatch.py from the plugin manifest) pre-loads all of the above into the session before the skill runs.

Error Handling

Navigator not found:

❌ Navigator not initialized

Run /nav:init to create .agent/ structure first.

PM tool configured but not working:

⚠️  [PM Tool] configured but not accessible

Check authentication or run setup guide.

Config file malformed:

⚠️  .agent/.nav-config.json is invalid JSON

Fix syntax or run /nav:init to regenerate.

Success Criteria

Session start is successful when:

  • Navigator loaded successfully
  • Token usage calculated and displayed
  • PM tool status checked (if configured)
  • User knows what to work on next
  • Navigator workflow context set

Notes

This skill provides the same functionality as /nav:start command but with:

  • Natural language invocation (no need to remember / syntax)
  • Auto-detection based on user intent
  • Composable with other Navigator skills

If user prefers manual invocation, they can still use /nav:start command (both work in hybrid mode).

© 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 4 other files (scripts) in skills/nav-start of qf-studio/navigator.

  • SKILL.md
  • functions/auto_updater.py
  • functions/test_auto_updater.py
  • functions/test_workflow_detector.py
  • scripts/otel_session_stats.py

Open the folder on GitHubat commit 3bb9eac

Compare with similar skills

Nav Start 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 Start compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Nav Start this skillqf-studio/navigator355—~4.7kAutomated safety check: NotesMIT
MCP Server Builderanthropics/skills180k63 repos~2.3kAutomated safety check: PassApache-2.0
Hook Development for Claude Code Pluginsanthropics/claude-plugins-official38k10 repos~4.1kAutomated safety check: NotesApache-2.0
Using Superpowersfarm-fe/farm5.6k36 repos~1.4kAutomated safety check: PassMIT
Executing Plans Inlineobra/superpowers297k2 repos~5.1kAutomated safety check: PassMIT
Skill CreatorAzure/azqr79689 repos~8.2kAutomated safety check: PassApache-2.0

Similar skills

  • MCP Server Builder

    anthropics/skills

    Official

    Guides the design and implementation of Model Context Protocol servers in TypeScript or Python, from tool naming and error messages to evaluation.

    180k GitHub starsUsed in 63 repos~2.3k tokens
    Agent WorkflowsAuto-check passed
  • Hook Development for Claude Code Plugins

    anthropics/claude-plugins-official

    Official

    Explains how to write Claude Code plugin hooks, both prompt-based checks and bash commands, for events such as PreToolUse, Stop and SessionStart.

    38k GitHub starsUsed in 10 repos~4.1k tokens
    Agent WorkflowsAuto-check: notes
  • Using Superpowers

    farm-fe/farm

    A skill your agent uses when starting any conversation - establishes how to find and use skills, requiring Skill tool invocation before ANY response including clarifying questions

    5.6k GitHub starsUsed in 36 repos~1.4k tokens
    Agent WorkflowsAuto-check passed
  • Executing Plans Inline

    obra/superpowers

    Has the agent carry out an implementation plan itself, task by task in the current session, keeping a ledger, proving each step with a test and ending with one whole-branch review.

    297k GitHub starsUsed in 2 repos~5.1k tokens
    Agent WorkflowsAuto-check passed
  • Skill Creator

    Azure/azqr

    Official

    Create new skills, modify and improve existing skills, and measure skill performance.

    796 GitHub starsUsed in 89 repos~8.2k tokens
    Agent WorkflowsAuto-check passed
  • Claude Code Agent Development

    anthropics/claude-plugins-official

    Official

    Explains how to write agents for Claude Code plugins: the markdown file with YAML frontmatter, trigger descriptions, model and color settings, and system prompt design.

    38k GitHub starsUsed in 7 repos~2.8k tokens
    Agent WorkflowsAuto-check passed

More from qf-studio/navigator

All 32 skills in this repo
  • Backend Endpoint

    qf-studio/navigator

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

    355 GitHub stars~4.5k tokensUpdated 2 days ago
    Auto-check: notes
  • Backend Test

    qf-studio/navigator

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

    355 GitHub stars~1.5k tokensUpdated 2 days ago
    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 2 days ago
    Auto-check: notes
  • Frontend Component

    qf-studio/navigator

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

    355 GitHub stars~4.5k tokensUpdated 2 days ago
    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 2 days ago
    Auto-check: notes
  • Nav Compact

    qf-studio/navigator

    Clear conversation context while preserving knowledge via context marker.

    355 GitHub stars~2.1k tokensUpdated 2 days ago
    Auto-check: notes

Categories

Questions about Nav Start

What does Nav Start do?

Load Navigator documentation navigator when starting development session, resuming work, or beginning new feature. Nav Start is an agent skill from qf-studio/navigator. Load Navigator documentation navigator when starting development session, resuming work, or beginning new feature.

When should I use Nav Start?

Nav Start fits situations like: user mentions starting work; beginning session; resuming after break; checking project status.

How do I install Nav Start in Claude Code?

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

How do I install Nav Start in Codex?

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

Can I use Nav Start 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-start -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-start, .gemini/skills/nav-start, .github/skills/nav-start and .opencode/skills/nav-start in your project.

What does Nav Start need to run?

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

Does Nav Start access the network?

SKILL.md contains no URLs. Its commands use gh, which can reach the network depending on how they are called. This is read from the text; nothing was executed.

Is Nav Start 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. The check reads SKILL.md only: the scripts in the folder are not scanned, so read them before running anything.

What licence does Nav Start use?

Nav Start 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 Start use?

About 4.7k tokens (SKILL.md is roughly 19k 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 Start?

Skills that share tags, products or a category with Nav Start: MCP Server Builder (anthropics/skills, 180k stars), Hook Development for Claude Code Plugins (anthropics/claude-plugins-official, 38k stars), Using Superpowers (farm-fe/farm, 5.6k stars) and Executing Plans Inline (obra/superpowers, 297k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Nav Start?

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.