LogNexus
OfficialLogNexus MCP server exposes tools to manage Git-backed AI-agent state, commits, review gates, timelines, notes, and local telemetry.
Inspect workspace, Git branch, active issue, routing mode, and recommended model tier.
Read, sync, set, finish, and clear persistent LogNexus session state and subtask contracts.
Create atomic Git commits with conventional messages, authorship/reviewer trailers, contract validation, task finishing, and Git Notes.
Show and attach LogNexus Git Notes to commits.
Generate branch Journey Timelines as tables, JSON, or PR body drafts.
Audit commits for review-gate compliance, traceability, notes coverage, contracts, and self-approval.
Inspect, enable, disable, report, inspect payloads for, or clear strictly local telemetry.
Provides a Git-backed knowledge graph and workflow: creates task branches, atomic task-scoped commits with trailers, attaches Git Notes under refs/notes/lognexus without changing commit SHAs, reconstructs branch timelines, and audits review-gate separation.
Integrates with GitHub issues and pull requests: turns plans into structured issues with subtasks, updates issue progress from commits, and compiles commit/discovery history into PR journey timelines for review.
LogNexus
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& MCPlognexus_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:vsReviewed-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.mdfrom 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 onstate set-taskand on every--finish-taskcommit.Live Scope-Drift Guard (
lognexus status/lognexus doctor): Diffs the working tree against theallowedFilesof 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
execFileSyncwithshell: falseand a 2500 ms timeout. The MCP transport is exempt.Git Notes Engine (Quiet Mode /
git-aiv3): Attaches structured session payloads and contracts to commits underrefs/notes/lognexuswithout 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 ( |
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 planTransforms 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 commitStages changes and generates structured, task-scoped commits (feat(#42/T1): ...) paired with an issue progress update.
4. Synthesize the Pull Request
/lognexus prCompiles all commits, discoveries, discarded alternatives, and verification steps into a comprehensive Journey Timeline inside the PR description.
5. Cross-Model Review & Gate Verification
/lognexus reviewAn 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-tokensVerify your environment anytime:
npx @digital-lake/lognexus doctorInspect active branch and tier advisory:
npx @digital-lake/lognexus statusManage 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 T1Execute 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-taskQuiet 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 originJourney 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 mainSession 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" --jsonOpt-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 disableTelemetry 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.jsonLinux:
~/.config/Claude/claude_desktop_config.jsonWindows:
%APPDATA%\Claude\claude_desktop_config.jsonCursor / VS Code:
.cursor/mcp.jsonor.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 claudeOr 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-mcpExposed 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_telemetryResources:
lognexus://state,lognexus://routingPrompts:
lognexus-plan,lognexus-review
3. Install Rules in Your Agent Environment
Claude Code:
claude plugin add digital-lake-ai/lognexusCursor / Codex / Agent Skills:
npx skills add digital-lake-ai/lognexusGoogle Antigravity: Active automatically via
skills/lognexus/SKILL.mdor workspace skills.Kimi Code / VS Code: Active via
.lognexus/workspace instructions and prompts.
⚡ Production Telemetry & Field Benchmark
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 |
| • Zero-drift multi-branch coordination• Strict review-gate enforcement ( | Architecture synthesis, closed contract authoring, cross-model code review, release governance. |
DeepSeek V3 / R1 |
| • 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 ( |
Kimi K2.7 Code |
| • Massive context retention with zero file truncation on large modules ( | Large-context refactorings, multi-file rule catalogs, CI/CD matrices & standalone packaging. |
Key Takeaway: Contract-driven development paired with
refs/notes/lognexuscompletely 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
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 ( |
Socket Security | Vulnerability audit | 100 / 100 — |
Socket Security | Quality & License compliance | 100 / 100 |
Socket Security | Maintenance health | 96 / 100 |
SLSA Provenance | Build supply chain | Verified ( |
License & Contribution model | Open governance | MIT — Open Source, Core-Maintained (Closed to Unsolicited External PRs) |
Awesome MCP Servers | Community MCP directory ( | Listed under Version Control ( |
Smithery & Claude Plugin | Native MCP & Plugin registries ( | Verified Cross-Platform ( |
MCP Registry & PyPI | Official | Verified ( |
Local-first by construction: LogNexus ships
0runtime network calls,0PII, and0telemetry endpoints. Seedocs/TELEMETRY_PRIVACY.mdandSECURITY.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 |
|
Implementation (VS Code client) |
|
Cross-model review (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, commitcd0582c1).
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:
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 toolslognexus_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
Scored across 12 tools
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.
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.
Twelve tools fit the workflow-management scope well. Each tool covers a meaningful state, commit, review, note, timeline, or telemetry operation without obvious filler.
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
Related MCP Connectors
Team memory for AI coding agents and code reviews, reviewed by humans and served over MCP.
Persistent AI memory shared across Claude, ChatGPT, coding agents, and compatible MCP clients.
Give your AI agent persistent, governed memory for every project. At task start it recalls the approved decisions, conventions, risks and architecture (semantic search, ranked by importance); at close it proposes what was learned as typed memories that you review and approve — governance, not a notes dump. Agents propose, humans govern: edits go back to pending and deletion is human-only by design. Connect Claude Code, Cursor, Claude Desktop or any MCP client in two minutes with just your API key — hosted (nothing to install) or locally via `uvx solucortex-mcp`. Built by SoluAI and dogfooded daily: SoluCortex is developed using its own living memory.
Shared brain, one current version of memory for any MCP client: ChatGPT, Claude, Gemini, Cursor
Related MCP Servers
- AlicenseAqualityBmaintenancePersistent 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.15342 npm2MIT
- AlicenseBqualityBmaintenancePersistent, local memory for AI coding agents that learns how you work, not just what you said. Supports Claude Code, Codex CLI, Cursor, and any MCP client.7998 PyPI77MIT

Memcellofficial
AlicenseNot gradedqualityFmaintenanceLiving memory for AI coding agents (Claude Code, Cursor, Copilot, Codex). Cross-vendor persistent memory, decision recall, and outcome calibration via MCP and hooks.919 npmApache 2.0- AlicenseNot gradedqualityAmaintenanceGives 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 npmISC