Skip to main content
Glama

LogNexus

CI npm version npm downloads LogNexus MCP server – quality and maintenance score on Glama Organization Ko-fi

SLSA Provenance Socket Security MCP TDQS TypeScript Node.js Platforms Privacy License: MIT


What is LogNexus?

As AI coding agents take on complex engineering tasks across different IDEs, they suffer from a fundamental failure mode: cognitive amnesia. Between conversation resets, context compactations, model handoffs, and unexpected bugs, the why behind design decisions, discarded alternatives, and technical discoveries vanishes.

LogNexus transforms Git and GitHub into a persistent, traceable knowledge graph. It is a 100% generic, model-agnostic and editor-agnostic framework that operates directly inside your native AI development environments:

  • Clients: Claude Code, Cursor, Codex, Google Antigravity, Kimi Code, VS Code, Zed.

  • Models: Google Gemini (Gemini 4 Argon, Gemini 4 Carbon, Gemini 3.8 Pro & Flash High), Moonshot AI (Kimi K3 / Kimi Code), DeepSeek (R1, V3, Chat), Anthropic Claude, OpenAI.

  • Supported Platforms: Linux, macOS, and Windows (linux, darwin, win32 — 100% cross-platform Node.js >= 20 & Git >= 2.28, zero native binary dependencies).

Issues (Why & Goals) ──▶ Branches (Task Scopes) ──▶ Commits (Context & Diffs) ──▶ PR (Timeline & Review)
         ▲                                                                                 │
         └─────────────────────── Git-Backed Knowledge Graph ──────────────────────────────┘

Framework, Not an API Proxy: LogNexus never intercepts network calls or wraps vendor APIs. Your models remain inside their native IDEs with full access to editor buffers, interactive diff viewers, terminals, MCP servers, and local tools.


Related MCP server: total-agent-memory

Key Features

  • Universal Multi-Model Support: Native cognitive guidelines and prompt specifications for Google Gemini (Gemini 4 Argon, Gemini 4 Carbon, Gemini 3.8 Pro & Flash High), Moonshot AI (Kimi K3 / Kimi Code), DeepSeek (R1, V3, Chat), Anthropic Claude, and OpenAI.

  • Universal Client Compatibility: Drop-in support for Claude Code, Cursor, Codex, Google Antigravity, and Kimi Code / VS Code.

  • Atomic Commit Engine (lognexus commit & MCP lognexus_commit): Validates subtask file contracts, verifies reviewer separation, injects authorship trailers, commits changes, marks subtasks completed, and attaches Git Notes in a single ~0.15s execution.

  • Cross-Model Review Gates: Non-negotiable review separation (Authored-by: vs Reviewed-by:) enforced both at pre-flight note attachment time and during branch audits. No model merges its own code without independent verification from another model family.

  • Contract-First Subtasks & Alphanumeric Tickets: Tasks are bounded by strict decision budgets, file allowlists, and stop conditions—supporting both GitHub issues (feat(#42/T1)) and Jira/Linear ticket schemes (feat(SLM-201/T1)).

  • Persistent State & Session Recovery: Local session state engine (.lognexus/state.json) prevents amnesia across context compactations and conversation resets, retaining completed subtask metadata through the closing commit.

  • Automated Context Handoff (lognexus handoff): Regenerates a complete .lognexus/handoff.md from local state — cycle state, active subtask contract, live scope-drift report, completed-subtask table and next required action — so a fresh session (or a different model) resumes without re-deriving context. Auto-refreshed on state set-task and on every --finish-task commit.

  • Live Scope-Drift Guard (lognexus status / lognexus doctor): Diffs the working tree against the allowedFiles of the active contract on every status and diagnostic run, catching out-of-contract writes before they reach a commit.

  • Memory Recall Filter (lognexus note search): Queries the LogNexus Git Notes history by file, model, issue or free text, returning the newest matches first — the reasoning behind a decision stays retrievable months later.

  • Startup Update & Legal Terms Gate: A non-interactive gate surfaces update and legal-terms requirements at CLI startup, consulting the npm registry through execFileSync with shell: false and a 2500 ms timeout. The MCP transport is exempt.

  • Git Notes Engine (Quiet Mode / git-ai v3): Attaches structured session payloads and contracts to commits under refs/notes/lognexus without changing commit SHAs.

  • Native MCP Stdio Server (lognexus mcp): Zero-dependency JSON-RPC 2.0 stdio server exposing LogNexus tools, live state resources, and prompts to Claude Desktop, Cursor, and any MCP client.

  • Journey Timeline & Review Gate Audit: Reconstructs the complete branch journey into structured PR descriptions (lognexus timeline --pr-body) and programmatically audits review gate separation (lognexus audit).

  • Hidden Metadata Envelopes: HTML comments preserve machine-parseable state (<!-- lognexus: kind: state ... -->) without cluttering human-readable markdown.

  • Scaffolding & Health CLI (@digital-lake/lognexus): Lightweight CLI for repository scaffolding (init), health diagnostics (doctor), and real-time status inspection (status).

  • Optional Multi-Model Token Shield (init --protect-tokens): Opt-in, zero-runtime-overhead workspace hygiene flag that scaffolds official context-exclusion and read-deny rules (.geminiignore, .aiexclude, .cursorignore, .claude/settings.json, .rooignore, .codeiumignore, .aiderignore) tailored to the agent ecosystems detected in your repository—preventing accidental token leakage on lockfiles and build artifacts, translating directly into lower context costs without touching the MCP server.


Model-Tier Routing Matrix

LogNexus organizes development phases into three cognitive tiers. You can assign any model or native client to any tier according to your team's workflow and cost preferences:

Operational Tiers

Tier

Cognitive Role

Anthropic Claude

OpenAI

Google Gemini

DeepSeek

Primary Activities

tier-1 (Reasoning)

Deep synthesis, architectural design, narrative review

Claude Opus 3.7 / 4.x

o3, o1, GPT-5

Gemini 4 Carbon / Argon, 3.8 Pro

DeepSeek R1

Brainstorming-to-issue planning, PR journey timeline synthesis, cross-model review sign-offs.

tier-2 (Context & Triage)

Long context ingestion, discovery triage, structured mapping

Claude Sonnet

GPT-4.1, GPT-4o

Gemini 3.8 Flash High / Pro (1M)

DeepSeek V3

Large codebase exploration, discovery classification, knowledge retrieval.

tier-3 (Execution)

Surgical implementation, template filling, fast execution

Claude Haiku

GPT-4o-mini

Gemini Flash

DeepSeek Chat (V3)

Subtask commits (feat(#N/Tk)), atomic code changes under closed contracts, timeline logging.

Example Deployment Setups

LogNexus adapts to your existing toolstack. Configure your advisory preferences in .lognexus/routing.md:

┌────────────────────────────────────────────────────────────────────────────────────────┐
│                                 POPULAR DEPLOYMENT SETUPS                              │
├────────────────────────────────────────────────────────────────────────────────────────┤
│ Setup A (Anthropic Pure):  Claude Opus (t1) + Claude Sonnet (t2) + Claude Haiku (t3)   │
│ Setup B (Google + DeepSeek): Gemini Pro (t1/t2) in Antigravity + DeepSeek Chat in Kimi │
│ Setup C (OpenAI + DeepSeek): OpenAI o3 (t1) in Cursor + DeepSeek Chat (t3) for code    │
│ Setup D (Claude + OpenAI):   Claude Opus (t1) for design + GPT-4o-mini (t3) for tasks  │
└────────────────────────────────────────────────────────────────────────────────────────┘

Quickstart & Golden Path

LogNexus coordinates the full issue-to-merge lifecycle through intuitive slash commands:

1. Capture the Plan

/lognexus plan

Transforms an exploratory brainstorm into a structured GitHub Issue with discrete subtasks (T1..Tn), verification criteria, and tier tags.

2. Start Work on a Clean Branch

/lognexus start <issue-number>

Creates an ID-prefixed branch (issue/<id>-<slug>) from the default branch tip and logs a signed [lognexus/session-start] note.

3. Commit with Traceability

/lognexus commit

Stages changes and generates structured, task-scoped commits (feat(#42/T1): ...) paired with an issue progress update.

4. Synthesize the Pull Request

/lognexus pr

Compiles all commits, discoveries, discarded alternatives, and verification steps into a comprehensive Journey Timeline inside the PR description.

5. Cross-Model Review & Gate Verification

/lognexus review

An independent model inspects the PR diff, verifies task contracts, and signs off (Reviewed-by: <model>) before merge.


Installation & Setup

1. Scaffold Rules & Manage State with the CLI

Initialize .lognexus/ rules, templates, and routing configuration:

npx @digital-lake/lognexus init

# Optional: scaffold official multi-model context-exclusion rules (zero runtime overhead)
# to prevent agents from burning tokens on lockfiles or build directories:
npx @digital-lake/lognexus init --protect-tokens

Verify your environment anytime:

npx @digital-lake/lognexus doctor

Inspect active branch and tier advisory:

npx @digital-lake/lognexus status

Manage persistent agent state (.lognexus/state.json) and session recovery:

npx @digital-lake/lognexus state sync
npx @digital-lake/lognexus state show
npx @digital-lake/lognexus state set-task T1 "Add user schema"
npx @digital-lake/lognexus state finish-task T1

Execute an Atomic Commit (validates subtask contract, enforces review-gate separation, injects trailers, commits, marks subtask completed, and attaches Git Note in a single ~0.15s call):

npx @digital-lake/lognexus commit -m "feat(#42/T1): add user schema" \
  --author "gemini/flash (antigravity)" \
  --reviewer "gemini/pro (lead-architect)" \
  --finish-task

# Or read message from file (cross-platform on Linux, macOS, and Windows shells):
npx @digital-lake/lognexus commit -F commit-msg.txt --finish-task

Quiet Mode with Git Notes (refs/notes/lognexus, standard git-ai v3):

npx @digital-lake/lognexus note attach HEAD
npx @digital-lake/lognexus note show HEAD
npx @digital-lake/lognexus note push origin

Journey Timeline reconstruction and Review Gate audit:

npx @digital-lake/lognexus timeline main
npx @digital-lake/lognexus timeline main --pr-body
npx @digital-lake/lognexus audit main

Session continuity, scope-drift and memory recall:

# Regenerate .lognexus/handoff.md from live state (--json for machines)
npx @digital-lake/lognexus handoff
npx @digital-lake/lognexus handoff --json

# Inspect the working tree against the active subtask contract
npx @digital-lake/lognexus status
npx @digital-lake/lognexus doctor

# Recall past reasoning from Git Notes, newest matches first
npx @digital-lake/lognexus note search "scope drift"
npx @digital-lake/lognexus note search --file src/cli.ts
npx @digital-lake/lognexus note search --issue 30 --limit 5
npx @digital-lake/lognexus note search --author "deepseek" --json

Opt-in Telemetry, Stack Profiling & ROI Cost-Savings Engine (100% local, zero network calls):

# Check telemetry status (disabled by default, 0% overhead)
npx @digital-lake/lognexus telemetry status

# Enable local telemetry (stores metrics only in .lognexus/telemetry.json)
npx @digital-lake/lognexus telemetry enable

# Generate .lognexus/telemetry.md report with ROI metrics
npx @digital-lake/lognexus telemetry report

# Inspect the exact local payload structure
npx @digital-lake/lognexus telemetry inspect

# Disable telemetry immediately
npx @digital-lake/lognexus telemetry disable

Telemetry is strictly local-only: no endpoint, no dispatch, no upload. The retired --share --accept-terms flags now fail with an explicit error, and pre-2.0.0 stores in community mode are migrated to local on read.

Read our strict Zero-PII, zero-network policy in docs/TELEMETRY_PRIVACY.md.

2. Connect via Model Context Protocol (MCP)

LogNexus includes a native, lightweight JSON-RPC 2.0 stdio server (lognexus mcp) with zero external SDK dependencies. Connect it to Claude Desktop, Cursor, Google Antigravity, or any MCP-compliant client:

claude_desktop_config.json or Cursor MCP settings — config file locations per operating system:

  • macOS: ~/Library/Application Support/Claude/claude_desktop_config.json

  • Linux: ~/.config/Claude/claude_desktop_config.json

  • Windows: %APPDATA%\Claude\claude_desktop_config.json

  • Cursor / VS Code: .cursor/mcp.json or .vscode/mcp.json

{
  "mcpServers": {
    "lognexus": {
      "command": "npx",
      "args": ["-y", "@digital-lake/lognexus", "mcp"]
    }
  }
}

Or install automatically via Smithery:

npx -y @smithery/cli install @digital-lake/lognexus --client claude

Or run via Python (uvx / pip from PyPI):

# Zero-install MCP stdio launch via uvx:
uvx lognexus-mcp

# Or install globally via pip / pipx:
pip install lognexus-mcp

Exposed Capabilities:

  • Tools: lognexus_status, lognexus_state_get, lognexus_state_sync, lognexus_state_set_task, lognexus_state_finish_task, lognexus_state_clear, lognexus_commit, lognexus_note_show, lognexus_note_attach, lognexus_timeline, lognexus_audit, lognexus_telemetry

  • Resources: lognexus://state, lognexus://routing

  • Prompts: lognexus-plan, lognexus-review

3. Install Rules in Your Agent Environment

  • Claude Code:

    claude plugin add digital-lake-ai/lognexus
  • Cursor / Codex / Agent Skills:

    npx skills add digital-lake-ai/lognexus
  • Google Antigravity: Active automatically via skills/lognexus/SKILL.md or workspace skills.

  • Kimi Code / VS Code: Active via .lognexus/ workspace instructions and prompts.


⚡ Production Telemetry & Field Benchmark

Corpus Analyzed Git Notes Coverage Traceability Audit Test Suite Health

LogNexus was battle-tested in a high-intensity production deployment governing the end-to-end engineering of an enterprise static analysis CLI and AI migration skill (Anonymous Project ID: prj-7a4e91c2) operating over 250,000+ lines of legacy code with 22 AST/CFG rules (SPH-001..SPH-022).

╔══════════════════════════════════════════════════════════════════════════════════════════════╗
║  LOGNEXUS TELEMETRY HUD // PRODUCTION SWARM BENCHMARK (PROJECT ID: PRJ-7A4E91C2)             ║
╠═════════════════════════════════════════════╦════════════════════════════════════════════════╣
║  ▸ GOVERNED FEATURES     12 Issues (#1-#12) ║  ▸ ORPHAN / UNTRACKED COMMITS   0 (0.0%)       ║
║  ▸ VERIFIED COMMITS      38 / 38 Signed     ║  ▸ SELF-APPROVAL VIOLATIONS     0 Blocked      ║
║  ▸ GIT NOTES ATTACHED    100% (git-ai v3)   ║  ▸ SCOPE CREEP INCIDENTS        0 (Allowlist)  ║
║  ▸ TEST SUITE INTEGRITY  536 Passed (100%)  ║  ▸ ATOMIC COMMIT LATENCY        ~0.15s / op    ║
╚═════════════════════════════════════════════╩════════════════════════════════════════════════╝

Multi-Model Swarm Performance Matrix

By enforcing Closed Delegation Contracts (allowedFiles, forbiddenFiles, decisionBudget: "none") and Cross-Model Review Gates, LogNexus coordinated three distinct AI model families in production without a single context leak or rogue commit:

Model Family

Assigned Tier

Production Strengths Observed

Optimal Contract Fit

Google Antigravity / Gemini Pro

tier-1 & tier-2(Architect & Orchestrator)

• Zero-drift multi-branch coordination• Strict review-gate enforcement (lognexus audit)• Rapid root-cause regression triage

Architecture synthesis, closed contract authoring, cross-model code review, release governance.

DeepSeek V3 / R1

tier-3(Scoped Implementer)

• Ultra-low latency & token cost• Exceptional at mathematical AST parsing, pushdown automata & CFG tokenization• Strict adherence to stop conditions when hitting out-of-scope test assertions

Algorithmic engines, deterministic parsers, isolated single-file modules (<500 LOC).

Kimi K2.7 Code

tier-2 & tier-3(High-Context Implementer)

• Massive context retention with zero file truncation on large modules (>500 LOC)• Flawless single-shot multi-file generation (rule catalogs + visitors + test suites)

Large-context refactorings, multi-file rule catalogs, CI/CD matrices & standalone packaging.

Key Takeaway: Contract-driven development paired with refs/notes/lognexus completely eliminated scope creep by Tier-3 implementers while keeping the public Git commit graph 100% clean and human-readable.


Disambiguation

LogNexus by Digital Lake is an open-source development framework and Git memory system for AI agents. It is not affiliated with academic research papers on industrial log compression (e.g. ISSTA 2026).


🛡️ Verified Quality & Supply-Chain Security

LogNexus MCP server – quality and maintenance score on Glama

Every published release is continuously measured against independent third-party evaluators. The table below summarises the current external audit snapshot:

Auditor

Scope

Result

Glama MCP Directory

Server quality & maintenance score (TDQS)

Triple A grading · TDQS 4.3 / 5.0 (Grade A)

Socket Security

Vulnerability audit

100 / 100 — 0 CVEs

Socket Security

Quality & License compliance

100 / 100

Socket Security

Maintenance health

96 / 100

SLSA Provenance

Build supply chain

Verified (SLSA Provenance, OIDC-signed npm publish)

License & Contribution model

Open governance

MIT — Open Source, Core-Maintained (Closed to Unsolicited External PRs)

Awesome MCP Servers

Community MCP directory (punkpeye/awesome-mcp-servers / HorchataHTML/awesome-mcp-servers)

Listed under Version Control (📇 🏠 🍎 🪟 🐧 — TypeScript, Local, macOS, Windows, Linux)

Smithery & Claude Plugin

Native MCP & Plugin registries (smithery.yaml, .claude-plugin/plugin.json, skills/lognexus/SKILL.md)

Verified Cross-Platform (Linux, macOS, Windows)

MCP Registry & PyPI

Official server.json & Python launcher (lognexus-mcp)

Verified (io.github.digital-lake-ai/lognexus · npx & uvx across Linux, macOS, Windows)

Local-first by construction: LogNexus ships 0 runtime network calls, 0 PII, and 0 telemetry endpoints. See docs/TELEMETRY_PRIVACY.md and SECURITY.md.

Provenance & Identities

Every commit carries signed provenance trailers (Planned-by: / Authored-by: / Reviewed-by:). Identities are declared with their canonical spellings:

Role

Canonical identity

Master Architecture & Security Orchestrators

Gemini 4 Argon · Gemini 4 Carbon

Implementation (VS Code client)

deepseek/VS Code (kimi-code)

Cross-model review (Antigravity)

Gemini 4 Carbon · google/gemini-3.8-flash-high (antigravity)

The Planned-by: trailer documents where an externally authored plan came from. It grants no review authority and no merge rights; an author model never writes its own Reviewed-by: trailer.


Provenance & Acknowledgments

LogNexus is engineered and maintained by HorchataHTML and Digital Lake, encompassing:

  • The full TypeScript runtime, repository scaffolding & diagnostic CLI, Persistent Agent State Engine, Atomic Commit Engine, Git Notes memory layer (refs/notes/lognexus), local-first FinOps telemetry, Multi-Model Token Shield, and native JSON-RPC 2.0 stdio MCP server (@digital-lake/lognexus / lognexus-mcp).

  • First-class multi-model tier routing and closed delegation contracts across Google Gemini (Gemini 4 Argon, Gemini 4 Carbon, Gemini 3.8 Pro & Flash High), Moonshot AI (Kimi K3 / Kimi Code), DeepSeek (R1, V3, Chat), Anthropic Claude, and OpenAI.

  • The cross-reference CI validation workflow (.github/workflows/cross-ref-check.yml), single-source-of-truth review/signing block architecture, and sub-skill anchor normalization authored by HorchataHTML (2026-08-04, commit cd0582c1).

The Master Architecture & Security Plan governing frontier-model support, supply-chain hardening, and cross-model review governance is authored and signed by Gemini 4 Argon and Gemini 4 Carbon (Master Architecture & Security Orchestrators).

Additional workflow inspirations and patterns are derived from OrchestKit and Superpowers. Detailed license texts and notices are preserved in the LICENSES/ directory and in NOTICE.md.

LogNexus is an independent continuation and full-stack TypeScript, CLI, and native MCP evolution of shiplog.


Did you find this project useful? 🤖⚡

Maintaining and evolving open-source agentic infrastructure takes time, dedication, and... quite a few AI tokens to power multi-model benchmarking, automated testing, and continuous architecture updates.

If LogNexus saved you time, prevented context amnesia in your workflows, and you'd like to help cover the API and compute costs to keep it evolving, consider fueling the AI with a token:

Ko-fi - Fuel the AI

Every contribution goes straight into compute power, multi-model benchmarks, new MCP capabilities, and continuous improvements!


License

LogNexus is released under the MIT License.
Copyright (c) 2026 HorchataHTML (https://github.com/digital-lake-ai/lognexus)
Copyright (c) 2026 Digital Lake and LogNexus contributors.
Copyright (c) 2026 devallibus

Available Tools

12 tools
lognexus_auditLogNexus Audit: Audit review gate and commit traceabilityA

Audit the branch commits against the LogNexus review gate: commit format, Authored-by trailer, Git Notes coverage, subtask file contracts, and author/reviewer separation including self-approval detection. Use when you need the pass/fail gate before merging or before opening a pull request. Not for producing the PR narrative (use lognexus_timeline); audit reports violations and never fixes them.

Inputs: baseBranch.

lognexus_commitLogNexus Commit: Atomic commit with Git Note and review gateA

Atomically create a Git commit with conventional commit format, authorship trailers, subtask file contract validation, optional task finishing, and Git Note attachment in a single operation. Use when creating any commit on a LogNexus branch, including the atomic subtask commits that close a Tn. Not for retro-attaching a note to a commit that already exists (use lognexus_note_attach), and not for bypassing the gate: the commit engine refuses to run on a protected branch and rejects files outside the contract.

Inputs: message (required), tier, author, reviewer, +3 more.

lognexus_note_attachLogNexus Note: Attach state as Git Note to commitA

Attach the current LogNexus state as a Git Note (refs/notes/lognexus) to a commit that already exists. Defaults to HEAD. Use when backfilling manually on commits created outside the commit engine, or repairing a missing note. Not for normal commits: lognexus_commit already attaches the note as part of the atomic operation, so attaching again is only needed when the note was lost.

Inputs: commitRef.

lognexus_note_showLogNexus Note: Show Git Note attached to commitA

Read the LogNexus Git Note (refs/notes/lognexus) attached to a commit and return its parsed JSON payload. Defaults to HEAD. Use when verifying that a commit carries the expected tier, subtask and contract before a review or a merge. Not for creating or repairing notes (use lognexus_note_attach).

Inputs: commitRef.

lognexus_state_clearLogNexus State: Clear session stateA

Reset the persistent LogNexus agent state to empty. Equivalent to 'lognexus state clear'. Use when abandoning an issue, switching to an unrelated task, or recovering from a corrupted state file. Not for finishing a single subtask (use lognexus_state_finish_task); clearing is destructive and drops the whole contract.

Inputs: no named parameters.

lognexus_state_finish_taskLogNexus State: Finish subtask and mark completedA

Mark a subtask as completed in the persistent state and return the updated state. Equivalent to 'lognexus state finish-task '. Use when the subtask work has already been committed and its Git Note attached. Not for creating the commit itself (use lognexus_commit with finishTask: true, which finishes the task atomically) and not for editing the contract (use lognexus_state_set_task).

Inputs: taskId (required).

lognexus_state_getLogNexus State: Get persistent session stateA

Return the persistent LogNexus agent state (.lognexus/state.json) as stored on disk: active issue, current subtask and its file contract, completed subtasks and last synchronization timestamp. Use when you need the current contract or completion list and nothing has changed the branch since the last sync. Not for validating the state against the Git branch or GitHub (use lognexus_state_sync), and not for starting or finishing subtasks (use lognexus_state_set_task or lognexus_state_finish_task).

Inputs: no named parameters.

lognexus_state_set_taskLogNexus State: Set active subtask and file contractA

Mark a subtask as in progress and persist its closed delegation contract (allowed files, forbidden files, decision budget, verification command) plus the active issue tier. Equivalent to 'lognexus state set-task [title]'. Use when you begin a new subtask and need the file scope enforced by the commit engine and the audit. Not for marking a subtask complete (use lognexus_state_finish_task) and not for reading the contract (use lognexus_state_get).

Inputs: taskId (required), tier, title, allowedFiles, +3 more.

lognexus_state_syncLogNexus State: Synchronize state from Git branch and GitHubA

Reconcile the persistent state with the current Git branch and GitHub metadata, rewriting .lognexus/state.json and returning the updated state. Use when you just checked out a branch, rebased, opened a PR, or suspect the stored state is stale. Not for a plain read of what is already on disk (use lognexus_state_get); sync mutates the store and runs git and gh.

Inputs: no named parameters.

lognexus_statusLogNexus Status: Inspect workspace and Git branch stateA

Inspect the current Git branch, whether the directory is a Git repository, the active issue, the routing mode and the recommended model tier. Use when you need a cheap read-only snapshot before choosing a branch, a tier, or a next action. Not for reading the subtask contract (use lognexus_state_get) or for refreshing the state from Git and GitHub (use lognexus_state_sync).

Inputs: no named parameters.

lognexus_telemetryLogNexus Telemetry: Local performance and ROI cost reportA

Inspect local telemetry status, enable strictly local performance metrics (zero network calls), disable tracking, inspect the zero-PII local payload, generate telemetry markdown reports, or clear the metrics store. Use when measuring subtask duration, Git Notes coverage and estimated cost savings. Not for any form of upload: telemetry is local-only, stored in .lognexus/telemetry.json, and no data leaves the working directory.

Inputs: action, outputPath.

lognexus_timelineLogNexus Timeline: Generate PR Journey TimelineA

Reconstruct the branch Journey Timeline against a base branch: commit list enriched with Git Notes, subtask IDs, tiers and Authored-by/Reviewed-by trailers, rendered as a Markdown table, JSON or a PR body draft. Use when preparing a pull request description or reviewing the subtask sequence of a branch. Not for judging compliance (use lognexus_audit, which reports violations rather than a narrative).

Inputs: format, baseBranch.

Tool Schema Changelog

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

Loading tool schema changelog…

    TDQS

    A4.3/5.0

    Scored across 12 tools

    Disambiguation4/5

    The tools mostly have distinct purposes, and descriptions explicitly cross-reference alternatives. However, a couple of boundaries still require careful reading, especially lognexus_state_finish_task versus lognexus_commit with finishTask:true, and lognexus_status versus lognexus_state_get.

    Naming Consistency4/5

    All tools share the lognexus_ prefix and use snake_case, with clear state_* and note_* action subgroups. Minor deviations are the top-level bare nouns/verbs such as lognexus_status, lognexus_audit, and lognexus_telemetry.

    Tool Count5/5

    Twelve tools fit the workflow-management scope well. Each tool covers a meaningful state, commit, review, note, timeline, or telemetry operation without obvious filler.

    Completeness4/5

    The surface covers the core lifecycle: state inspection/sync, task set/finish/clear, commit creation, Git Notes, audit, timeline, and telemetry. Minor gaps exist around higher-level GitHub operations such as opening or merging a PR directly, though timeline and audit support the surrounding workflow.

    Maintenance

    ActivityMaintained
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      A
      quality
      B
      maintenance
      Persistent memory MCP server for Claude Code, Cursor, and GitHub Copilot. Semantic search, Git sync, project-based, Persistent memory MCP server for Claude Code, Cursor, and GitHub Copilot. Semantic search, Git sync, project-based organization, and team collaboration via Model Context Protocol.
      15
      342 npm
      2
      MIT
    • A
      license
      Not graded
      quality
      F
      maintenance
      Living memory for AI coding agents (Claude Code, Cursor, Copilot, Codex). Cross-vendor persistent memory, decision recall, and outcome calibration via MCP and hooks.
      919 npm
      Apache 2.0
    • A
      license
      Not graded
      quality
      A
      maintenance
      Gives AI coding agents persistent, cross-session memory by storing task insights as interlinked markdown knowledge cards and recalling relevant ones before new work begins. Uses plain files and git sync instead of a vector database or embeddings, and exposes this through MCP tools for Claude Code, Cursor, VS Code Copilot, Codex, Windsurf, and other clients.
      9 npm
      ISC