JSPM

• AST Code Indexing — Tree-sitter parsing for 21 languages (13 with full symbol extraction + 8 grammar-only); symbol-aware BM25 tokenization boosts function/class names in search results
• Web Search — Real-time search via Perplexity Sonar through OpenRouter (quick $1/MTok, quality $3-15/MTok, deep research); search history tracking with cost auditing
• PRD Pipeline — Generate PRDs from feature descriptions, parse into executable tasks, run with Claude Code agent, export workflow to Obsidian (Mermaid Gantt + dependency DAG)
• Team Mode — Parallel task execution using git worktrees; each worker gets an isolated checkout, results merge via cherry-pick
• Quality Gates — Auto-detected (TypeScript, Go, Python, Rust) or custom; run after each task to verify code quality
• Graph Algorithms — Personalized PageRank (PPR) retrieval, Tarjan's SCC, articulation points, Dijkstra shortest path, betweenness centrality, Louvain communities with LLM summaries, bridge edges (code↔memory graph)
• Cross-encoder Reranker — ONNX ms-marco-MiniLM-L6-v2 rescores (query, document) pairs; configurable weight, topK clamping, graceful degradation
• HyDE — Hypothetical Document Embeddings via LLM for natural language → code search; tree-sitter AST code detection
• Late Chunking — Long-context embedding (jina 8192 tokens) with per-AST-chunk pooling for context-aware embeddings
• Hierarchical Summaries (RAPTOR-style) — bottom-up LLM summarization at file → directory → module → repo zoom levels with query routing
• Code Scanning — succ_index action="scan" recursively discovers and indexes code files via git ls-files / directory walk with .succignore, size filtering, symlink rejection
• Observability — search latency, embedding times, LLM call metrics; retrieval feedback loop for ranking adjustment
• Auto-memory Extraction — session-end fact extraction via LLM with quality gate + periodic dimension-bucketed consolidation
• Cross-repo Search — search across multiple succ-indexed repositories
• Diff-brain Analysis — LLM-powered diff analysis for brain vault document changes
• LSP Integration — language server protocol client, installer, and server registry (Kotlin + Swift added)
• MCP Review Tool — succ_review for code review with blast-radius estimation
• Co-change Analysis — git log mining to detect files frequently changed together
• Brain Vault Export — structured export with metadata
• API Versioning — /v1/ route prefix aliases for all daemon endpoints
• Graph Enrichment — LLM-classified relations (implements, leads_to, contradicts...), contextual proximity, Label Propagation communities, degree centrality with recall boost
• Dead-End Tracking — Record failed approaches; auto-boosted in recall to prevent retrying
• AGENTS.md Auto-Export — Auto-generate editor instructions from decisions, patterns, dead-ends
• Learning Delta — Track knowledge growth per session (memories added, types, quality)
• Confidence Retention — Time-decay scoring with auto-cleanup of low-value memories
• Safe Consolidation — Soft-delete with undo support; no data loss on merge
• Skill Discovery — Auto-suggest relevant skills based on user prompt (opt-in, disabled by default)
• Skyll Integration — Access community skills from Skyll registry (requires skills.enabled = true)
• Soul Document — Define AI personality and values
• Dynamic Hook Rules — Memories tagged hook-rule auto-fire before matching tool calls; filter by tool:{Name} and match:{regex} tags; error type blocks, pattern asks confirmation, allow type auto-approves permission dialogs (v2.1.63+), others inject as context
• PermissionRequest — Auto-approve or deny Claude Code permission dialogs based on memory rules (requires Claude Code v2.1.63+)
• HTTP Hooks — Direct HTTP hooks to daemon (no process spawn) for faster, more reliable hook execution (requires Claude Code v2.1.63+, auto-detected at succ init)
• File-Linked Memories — Attach memories to files via files parameter; pre-tool hook auto-recalls related memories when editing those files
• Auto-Hooks — Context injection at session start/end
• Idle Reflections — AI generates insights during idle time
• Session Context — Auto-generated briefings for next session
• Security Hardening — 3-tier prompt injection detection (structural + multilingual regex + embedding semantic), content sanitization for 13 entry points, Bell-LaPadula IFC with compartments, file operation guards, exfiltration detection, post-tool secret scanning
• LLM Guardrails — Optional Tier 3 LLM classification (Llama Guard, safeguard-20b) for sensitivity, code policy (OWASP SC2-SC7), and injection detection with LRU caching
• Sensitive Filter — Detect and redact PII, API keys, secrets
• Quality Scoring — Local ONNX classification to filter noise
• Token Savings — Track RAG efficiency vs full files
• Temporal Awareness — Time decay, validity periods, point-in-time queries
• Unified Daemon — Single background process for watch, analyze, idle tracking
• Watch Mode — Auto-reindex on file changes via @parcel/watcher
• Fast Analyze — --fast mode with fewer agents and smaller context for quick onboarding
• Incremental Analyze — Git-based change detection, skip unchanged agents
• Local LLM — Ollama, LM Studio, llama.cpp support
• Sleep Agent — Offload heavy operations to local LLM
• Checkpoints — Backup and restore full succ state
• AI-Readiness Score — Measure project readiness for AI collaboration
• Multiple LLM Backends — Local (Ollama), OpenRouter, or Claude CLI
• Storage Backends — SQLite (default), PostgreSQL + pgvector, Qdrant
• Data Migration — Export/import JSON, migrate between backends

Local (default):

{
  "llm": { "embeddings": { "mode": "local" } }
}

Ollama (unified namespace):

{
  "llm": {
    "embeddings": {
      "mode": "api",
      "model": "nomic-embed-text",
      "api_url": "http://localhost:11434/v1/embeddings"
    }
  }
}

OpenRouter:

{
  "embedding_mode": "openrouter",
  "openrouter_api_key": "sk-or-..."
}

MRL dimension override (Matryoshka models):

{
  "llm": {
    "embeddings": {
      "mode": "api",
      "model": "nomic-embed-text-v1.5",
      "api_url": "http://localhost:11434/v1/embeddings",
      "dimensions": 256
    }
  }
}

succ uses native ONNX Runtime for embedding inference with automatic GPU detection:

GPU is enabled by default. No manual configuration needed — the best available backend is auto-detected.

{
  "gpu_enabled": true,
  "gpu_device": "directml"
}

Set gpu_device to override auto-detection: cuda, directml, coreml, or cpu.

Automatically run the succ-diff-reviewer agent before every git commit to catch security issues, bugs, and regressions:

{
  "preCommitReview": true
}

When enabled, Claude will run a diff review before each commit. Critical findings block the commit; high findings trigger a warning.

Disabled by default. Set via succ_config(action="set", key="preCommitReview", value="true").

When running with --dangerously-skip-permissions, succ's security guards can block autonomous operations. Enable trustAgentPermissions to downgrade deny/ask to context warnings:

{
  "security": {
    "trustAgentPermissions": true
  }
}

Injection detection stays ON (protects the agent). See Security Hardening for details.

Offload heavy operations to local LLM:

{
  "idle_reflection": {
    "sleep_agent": {
      "enabled": true,
      "mode": "local",
      "model": "qwen2.5-coder:14b",
      "api_url": "http://localhost:11434/v1"
    }
  }
}

succ supports multiple storage backends for different deployment scenarios:

Example: PostgreSQL + pgvector

{
  "storage": {
    "backend": "postgresql",
    "postgresql": {
      "connection_string": "postgresql://user:pass@localhost:5432/succ"
    }
  }
}

Example: PostgreSQL + Qdrant

{
  "storage": {
    "backend": "postgresql",
    "vector": "qdrant",
    "postgresql": { "connection_string": "postgresql://..." },
    "qdrant": { "url": "http://localhost:6333" }
  }
}

See Storage Configuration for all options.

succ supports multiple LLM backends for operations like analyze, idle reflection, and skill suggestions:

{
  "llm": {
    "type": "local",
    "model": "qwen2.5:7b",
    "local": {
      "endpoint": "http://localhost:11434/v1/chat/completions"
    },
    "openrouter": {
      "model": "anthropic/claude-3-haiku"
    }
  }
}

Transport auto-selects based on type: claude uses process (or ws for persistent WebSocket), local/openrouter use http.

WebSocket transport (transport: "ws") keeps a persistent connection to Claude CLI, avoiding process spawn overhead on repeated calls:

{
  "llm": {
    "type": "claude",
    "model": "sonnet",
    "transport": "ws"
  }
}

Per-backend model overrides for the fallback chain:

{
  "llm": {
    "type": "claude",
    "model": "sonnet",
    "transport": "ws",
    "local": { "endpoint": "http://localhost:11434/v1/chat/completions", "model": "qwen2.5:7b" },
    "openrouter": { "model": "anthropic/claude-3-haiku" }
  }
}

Claude backend usage

The claude backend integrates with an existing, locally running Claude Code session and is intended only for in-session developer assistance by the same user, including tasks such as file analysis, documentation, indexing, and session summarization.

It is not supported for unattended background processing, cloud deployments, or multi-user scenarios. For automated, long-running, or cloud workloads, use the local or openrouter backends instead.