{ "markdown": "# Nexus Agents\n\n[![OpenSSF Best Practices](https://www.bestpractices.dev/projects/12365/badge)](https://www.bestpractices.dev/projects/12365) [![OpenSSF Scorecard](https://api.securityscorecards.dev/projects/github.com/nexus-substrate/nexus-agents/badge)](https://securityscorecards.dev/viewer/?uri=github.com/nexus-substrate/nexus-agents)\n\n> Autonomic control plane for AI coding agents — one entry point, adversarial review, tamper-evident hash-chained audit, human-gated closed-loop tuning (autonomous demotion, earned promotion)\n\n[![npm version](https://img.shields.io/npm/v/nexus-agents)](https://www.npmjs.com/package/nexus-agents)\n[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)\n[![Node.js Version](https://img.shields.io/badge/node-%3E%3D22.0.0-brightgreen)](https://nodejs.org)\n[![Claims Registry Drift](https://img.shields.io/github/actions/workflow/status/nexus-substrate/nexus-agents/docs-check.yml?branch=main&label=claims%20registry)](https://github.com/nexus-substrate/nexus-agents/actions/workflows/docs-check.yml)\n\n---\n\n## Why Nexus Agents?\n\n**Nexus-agents is an autonomic control plane for your AI coding agents** — Claude Code, Codex, Gemini, and OpenCode. The agents are the _data plane_: they do the engineering. Nexus-agents is the _control plane_: it admits work through one entry point, reviews it adversarially before it ships, records every action in a tamper-evident event log, and closes the loop by tuning where the next task goes based on what actually worked.\n\nBorrowing the vocabulary of [autonomic computing](https://en.wikipedia.org/wiki/Autonomic_computing): the system runs a **MAPE-K** loop — Monitor, Analyze, Plan, Execute over a shared Knowledge base — so that operating your agent fleet is, as much as the evidence allows, self-managing rather than hand-driven.\n\n### The control-plane mapping\n\nEach classic control-plane role maps to a shipped nexus-agents component — the metaphor is load-bearing, not decoration:\n\n| Control-plane role | nexus-agents component | What it does |\n| ------------------ | --------------------------------------------------------- | ------------------------------------------------------------------------- |\n| Scheduler | `run` / MetaOrchestrator | One entry point picks (and optionally runs) the right strategy for a goal |\n| Admission control | gates (`pr_review`, `consensus_vote`, `run_quality_gate`) | Adversarial review and quality gates decide what is allowed to ship |\n| Event log | `AuditTrail` hash chain + `verify_audit_chain` | Append-only, tamper-evident record of every decision |\n| Data plane | engineering CLIs | Claude Code, Codex, Gemini, OpenCode do the file edits, tests, PRs |\n\n### The MAPE-K loop\n\n```\n ┌────────── Monitor ──────────┐ OutcomeStore · AuditTrail · swarm-health\n │ ▼ adapter circuit-breaker signals\nExecute ◀── Plan ◀── Analyze ◀───┘ LinUCB + TOPSIS scoring, consensus\n │ │ MetaOrchestrator strategy choice\n │ └── route the next task ──────────────────────────────────────┐\n ▼ │\n run the strategy ── adversarial review ── audit ── feed outcome back ──────┘\n shared Knowledge: OutcomeStore + memory backends + audit log\n```\n\n### Self-\\* capabilities\n\nAutonomic systems are described by their **self-\\*** properties. Each row below maps to a loop that **exists in the codebase today** — nothing here is aspirational, and the authority each loop carries is bounded by [ADR-0017's authority ladder](docs/adr/0017-authority-ladder.md) (`observe → suggest → advisory → enforce`):\n\n| Self-\\* property | What it means here | Implementing loop (shipped) |\n| ---------------- | ------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------ |\n| Self-configuring | Detects environment and wires itself in | `nexus-agents setup` / `doctor` (`cli-commands.ts`) — detects CLIs, writes MCP config, reports health |\n| Self-healing | Routes around failing dependencies automatically | Adapter circuit-breaker + swarm-health demotion (`cli-adapters/circuit-breaker.ts`); a capped, auto-decaying, demotion-only `TuneAdjustmentStore` adjustment |\n| Self-optimizing | Learns where the next task should go | Closed-loop `OutcomeStore` → LinUCB + TOPSIS scoring in the `CompositeRouter` |\n| Self-protecting | Constrains what untrusted input and tools can do | Trust-tiered input handling, ClawGuard access-policy reporting (advisory), Docker/policy sandboxing (`security/`) |\n\n> **Honesty note:** these loops sit at different rungs of the authority ladder. The self-tuning demotion is `enforce` but bounded (capped, auto-decaying, demotion-only); learned selection and other promotions are still **earned** per-loop against an evidence threshold plus ratification, not flipped on by default. See [ADR-0017](docs/adr/0017-authority-ladder.md).\n\n**What it gives you:**\n\n- **Adversarial PR review** — `pr_review` runs 5 voter roles (architect, security, devex, catfish, scope_steward) with a 4-point verification gate. On the v5 evaluation set: 100% bug-catch on a focused synthetic dataset (n=10) and a 50% raw false-positive rate; manual triage reclassified one of two inspected FP cases as a real finding the dataset had mislabeled. These are directional small-n figures, not measured rates. Full numbers and guardrails: [docs/research/pr-review-experiment-results-v5.md](docs/research/pr-review-experiment-results-v5.md)\n- **Drift-detected charter** — `CLAUDE.md` + `governance:check` + blocking CI gates fail the build when documented rules drift from registered behavior (model registry, MCP tools, expert types, skills)\n- **Tamper-evident audit trail** — every tool call, every voter decision, every routing choice flows through `AuditTrail` with structured logging and hash-chained append-only storage; integrity is verifiable via the `verify_audit_chain` MCP tool (tamper-evident, not tamper-proof — see the [audit hash-chain threat model](docs/security/audit-hash-chain-threat-model.md))\n- **Closed-loop routing** — `OutcomeStore` feeds production telemetry back into LinUCB + TOPSIS scoring so the system actually learns from what shipped vs what regressed. A second, **bounded** loop runs by default: a `signal.swarm_unhealthy` (adapter circuit-breaker / swarm-health) applies a small, capped, auto-decaying routing demotion via `TuneAdjustmentStore` — demotion-only, never zeroes a CLI, every adjustment audited, opt-out with `NEXUS_TUNE_ENFORCE=false`\n- **Multi-voter consensus** — `consensus_vote` runs a default 7-role panel (architect, security, devex, ai_ml, pm, catfish, scope_steward; `--quick` uses 3). Six strategy names (five distinct: `higher_order` is an alias of `opinion_wise`, #514): simple/super-majority, unanimous, higher-order Bayesian, opinion-wise, proof-of-learning\n\n```\nYou: \"Review this PR / orchestrate this task / vote on this proposal\"\n ↓\nControl plane: admit → schedule/route → adversarial review → audit → learn from outcome\n ↓\nData plane (agents): Claude Code · Codex · Gemini · OpenCode\n ↓\nCode: actual edits, tests, PRs, issues\n```\n\n**What this is NOT:**\n\n- **Not another autonomous coding agent.** OpenHands, SWE-agent, AutoGen, Devin, Factory — those are the data plane. Nexus-agents is the control plane above them. Use whichever agents fit; we admit, review, audit, and route their work\n- **Not a chat framework.** Nothing here orchestrates conversations. It orchestrates real CLI tool invocations with real file I/O and outcome tracking\n- **Not a model API proxy.** The value is the admission gates, the audit, and the closed-loop tuning. Routing is a consequence of the control-plane work, not the product\n- **Not fully autonomous.** \"Autonomic\" means self-managing within bounds, not unsupervised. Every loop's authority is capped by the authority ladder (ADR-0017); promotions to higher authority are earned against evidence and human ratification, never flipped on by default\n\n---\n\n## Where nexus-agents sits in your stack\n\n```\n Human / IDE / CLI\n (Claude Code, Cursor, VS Code, terminal)\n │ MCP Protocol\n ▼\n ┌─────────────────────────────────────────────────────┐\n │ CONTROL PLANE — what nexus-agents provides │\n │ │\n │ Scheduler: run / MetaOrchestrator │\n │ Admission control: PR review · consensus · gates │\n │ Event log: tamper-evident hash-chained audit │\n │ Closed-loop self-tuning (MAPE-K) │\n │ │\n │ 47 MCP tools · multi-stage CompositeRouter │\n └────────────────────────┬────────────────────────────┘\n │\n ▼ delegates execution to\n ┌─────────────────────────────────────────────────────┐\n │ DATA PLANE — the agents that do the actual work │\n │ │\n │ Claude Code · Codex · Gemini · OpenCode │\n └────────────────────────┬────────────────────────────┘\n │\n ▼ produces\n Code, tests, PRs, issues\n```\n\nThe control plane is the layer that catches the mistakes data-plane agents would otherwise make — bad code shipped, rules drifting from intent, audit gaps, telemetry-free routing — and routes the next task based on what actually worked the last time.\n\n---\n\n## Quick Start (2 minutes)\n\n### 1. Install\n\n```bash\nnpm install -g nexus-agents\n```\n\n**Or as a Claude Code plugin** (single-command install from the official marketplace):\n\n```\n/plugin install nexus-agents\n```\n\nSee [docs/getting-started/PLUGIN_INSTALL.md](docs/getting-started/PLUGIN_INSTALL.md) for plugin-specific setup, or [llms-install.md](llms-install.md) for the short install guide an AI agent can follow.\n\n### 2. Verify\n\n```bash\nnexus-agents doctor\n```\n\nPrints a health table — Node version, configured CLIs (claude / codex / gemini / opencode), API keys missing vs present. Read-only; safe to run any time.\n\n### 3. See what success looks like (60-second smoke task — no API keys needed)\n\n```bash\nnexus-agents vote --quick --proposal \"Use SQLite over JSON files for the outcome store\"\n```\n\nYou should see:\n\n```\nNexus Agents Consensus Vote\n============================\n\nCollecting votes from 3 agents (timeout: 60s each)...\n\nProposal: Use SQLite over JSON files for the outcome store\n\nVotes\n\n ✓ Software Architect: APPROVE (86%)\n ✓ Security Engineer: APPROVE (74%)\n ✓ Scope Steward: APPROVE (91%)\n\nSummary\n\n Approve: 3\n Reject: 0\n Abstain: 0\n Approval: 100.0%\n Threshold: simple_majority\n\nResult: APPROVED\n\nCompleted in ~30s\n```\n\nThree voter roles deliberate via whichever local CLIs you have (Claude, Codex, Gemini) — no API keys required. Per-voter reasoning is recorded; the terminal prints the verdict. Mixed outcomes (some approve / some reject) and graceful error handling are demonstrated on the [project site hero](https://nexus-substrate.github.io/nexus-agents/) with a real 7-voter run.\n\n### 4. Wire into your editor\n\n```bash\nnexus-agents setup # Auto-configures MCP server in Claude Code, Cursor, etc.\n```\n\nRestart your editor. The 47 MCP tools (`orchestrate`, `consensus_vote`, `research_synthesize`, `verify_audit_chain`, …) become available to whatever agent you're already using.\n\n#### What `setup` configures\n\nBy default, `setup` writes/updates up to seven things in your environment. Each can be skipped with the corresponding `--skip-*` flag if you don't want it.\n\n| Configured | Where written | Opt-out flag |\n| -------------------------------- | ---------------------------------------------------- | ----------------- |\n| MCP server registration (Claude) | `~/.claude/mcp.json` / Claude Desktop config | `--skip-mcp` |\n| Project rules | `.cursor/rules/` and/or `.claude/rules/` | `--skip-rules` |\n| Session hooks | `~/.claude/hooks/` (session-start / pre-tool / etc.) | `--skip-hooks` |\n| OpenCode MCP config | `~/.config/opencode/opencode.json` | `--skip-opencode` |\n| Gemini MCP config | `~/.gemini/mcp.json` | `--skip-gemini` |\n| Codex MCP config | `~/.codex/config.toml` | `--skip-codex` |\n| Project config file | `./nexus-agents.yaml` | `--skip-config` |\n\nRun with `--interactive` (the default) for a per-step confirm flow, or `--no-interactive` to accept all defaults.\n\n### 5. Standalone usage (no editor required)\n\n```bash\nexport ANTHROPIC_API_KEY=your-key\nnexus-agents orchestrate \"Explain the architecture of this codebase\"\n```\n\n> **Security:** In default MCP mode, the server communicates only via stdio with the parent process (no network exposure). The REST API (opt-in) auto-generates an API key on first start. For network-exposed deployments, set `NEXUS_AUTH_ENABLED=true`. See [SECURITY.md](./docs/architecture/SECURITY.md).\n\n---\n\n## Capabilities\n\n| Category | Details |\n| ------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |\n| **Adversarial PR Review** | `pr_review` MCP tool: 5 voter roles (architect, security, devex, catfish, scope_steward) with 4-point gate. v5 evaluation (focused synthetic dataset, n=10): 100% bug-catch, 50% raw FP rate; manual triage reclassified one of two inspected FP cases as a real finding (directional small-n, not measured rates) ([details](docs/research/pr-review-experiment-results-v5.md)) |\n| **Consensus Voting** | 6 strategies: simple_majority, supermajority, unanimous, higher_order (Bayesian correlation-aware), opinion_wise, proof_of_learning |\n| **Drift-Detected Charter** | `CLAUDE.md` + `inject-governance.ts check` enforces single-source registries (model registry, MCP tools, expert types). Blocking CI gate fails build on drift |\n| **Audit Trail** | Structured logging for every tool call, voter decision, and routing choice. Tamper-evident hash-chained append-only storage (tamper-evident, not tamper-proof — see [threat model](docs/security/audit-hash-chain-threat-model.md)); integrity verifiable via `verify_audit_chain` MCP tool |\n| **Closed-Loop Telemetry** | `OutcomeStore` feeds LinUCB + TOPSIS scoring; a second bounded, audited self-tuning loop demotes unhealthy CLIs (capped, auto-decaying, on by default, opt-out `NEXUS_TUNE_ENFORCE=false`) |\n| **Security Pipeline** | Sandboxing (Docker/policy), trust-tiered input handling, SARIF parsing, red-team patterns, ClawGuard access-policy reporting (advisory) |\n| **Multi-Expert Orchestration** | 12 built-in expert types coordinated by Orchestrator. Roles bind prompt + tools + memory |\n| **Development Pipeline** | Research → Plan → Vote → Decompose → Implement → QA → Security. Three modes: autonomous, harness (caller implements), dry-run |\n| **Memory & Learning** | 5 user-facing backends (session, belief, agentic, adaptive, typed). Cross-session persistence feeds routing decisions |\n| **Research System** | 9 discovery sources (arXiv, GitHub, Semantic Scholar, etc). Auto-catalog, quality scoring, synthesis into topic clusters |\n| **Graph Workflows** | DAG-based workflow execution with checkpoint/resume, state reduction, and event hooks |\n| **47 MCP Tools** | Agent management, workflow execution, research, memory, codebase intelligence, repo analysis, consensus, operations |\n\n---\n\n## Available Experts\n\n| Expert | Specialization |\n| -------------- | -------------------------------------------- |\n| Code | Implementation, debugging, optimization |\n| Architecture | System design, patterns, scalability |\n| Security | Vulnerability analysis, secure coding |\n| Testing | Test strategies, coverage, test generation |\n| QA | Acceptance criteria, regression checks |\n| Documentation | Technical writing, API docs |\n| DevOps | CI/CD, deployment, infrastructure |\n| Research | Literature review, state-of-the-art analysis |\n| PM | Product management, requirements, priorities |\n| UX | User experience, usability, accessibility |\n| Infrastructure | Server management, bare metal, networking |\n| Data Viz | Charts, dashboards, visual data presentation |\n\n---\n\n## Supported CLIs & Providers\n\nNexus-agents routes tasks through 4 CLI adapters, each connecting to major AI providers:\n\n| CLI | Provider | Best For |\n| -------- | -------------------- | ------------------------------ |\n| claude | Anthropic (Claude) | Complex reasoning, analysis |\n| gemini | Google (Gemini) | Long context, multimodal |\n| codex | OpenAI (Codex) | Code generation, reasoning |\n| opencode | Custom OpenAI-compat | Custom endpoints, local models |\n\n`codex` has two transports, selected by configuration rather than by name:\n`CodexMcpAdapter` (the default, MCP-native) and `CodexCliAdapter` (subprocess).\nAn earlier version of this table listed `codex-mcp` as a fifth CLI, which no\n`CliNameSchema` will validate — `CLI_NAMES` has four members, so configuration\nnaming `codex-mcp` fails Zod parsing with nothing on the docs side to explain\nwhy.\n\n---\n\n## CLI Commands\n\n```bash\nnexus-agents # Start MCP server (default)\nnexus-agents doctor # Check installation health\nnexus-agents setup # Configure Claude CLI integration\nnexus-agents orchestrate \"...\" # Run task with experts\nnexus-agents vote \"proposal\" # Multi-agent consensus voting\nnexus-agents review # Review a GitHub PR\nnexus-agents expert list # List available experts\nnexus-agents workflow list # List workflow templates\nnexus-agents config init # Generate config file\nnexus-agents init --portable # Create workspace-local .nexus-agents/ for sandboxes\nnexus-agents init --portable --mcp-config # Also emit .mcp.json wiring Claude Code to it\nnexus-agents init --portable --install --mcp-config # …and install the binary into the workspace\nnexus-agents fitness-audit # Run fitness score audit\nnexus-agents research query # Query research registry\nnexus-agents --help # Full command list\n```\n\nSee [docs/ENTRYPOINTS.md](./docs/ENTRYPOINTS.md) for the complete CLI reference (28+ commands).\n\n---\n\n## MCP Tools\n\nWhen running as an MCP server, the following tools are available. **Start with `run`** — the default entry point: give it a goal and the MetaOrchestrator picks (and, with `execute: true`, runs) the right strategy. The other pipeline tools are advanced force-strategy paths for pinning a specific one.\n\n\n\n\n\n| Tool | Description |\n| ----------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |\n| `orchestrate` | Task orchestration with Orchestrator coordination |\n| `create_expert` | Create a specialized expert agent |\n| `execute_expert` | Run a task through a previously-created expert (by expertId) |\n| `run_workflow` | Run a linear workflow template (use `run_graph_workflow` for DAGs) |\n| `delegate_to_model` | Pick the best-fit existing model for a task (no registry change) |\n| `list_experts` | Inventory of expert ROLES for `create_expert` |\n| `list_workflows` | Inventory of multi-step TEMPLATES for `run_workflow` |\n| `consensus_vote` | Multi-model consensus voting on proposals |\n| `research_query` | Query research registry (status, overlap, stats, search) |\n| `research_add` | Add an arXiv PAPER to the registry (for non-paper sources use `research_add_source`) |\n| `research_add_source` | Add a NON-PAPER source (repo/tool/blog) — for arXiv papers use `research_add` |\n| `research_discover` | Discover papers/repos from external sources |\n| `research_analyze` | Analyze registry for gaps, trends, coverage |\n| `research_catalog_review` | Review auto-cataloged research references |\n| `research_synthesize` | Synthesize registry into topic clusters with themes |\n| `survey_oss_landscape` | Transient OSS project search (license, stars, last-commit) via GitHub |\n| `vendor_publishing_audit` | Look up a vendor's signing infrastructure (GPG keys, URL patterns, signature shape) |\n| `compare_data_feeds` | Diff two YAML/JSON feeds: coverage + per-field axes |\n| `memory_query` | Query across all memory backends |\n| `memory_stats` | Memory system statistics dashboard |\n| `memory_write` | Write to typed memory backends |\n| `weather_report` | Multi-CLI performance weather report |\n| `issue_triage` | Triage GitHub issues with trust classification |\n| `run_graph_workflow` | Run a DAG workflow with per-node checkpoints + audit trail (linear → `run_workflow`) |\n| `execute_spec` | Execute AI software factory spec pipeline |\n| `registry_import` | Draft YAML for a NEW model entry (for picking existing models use `delegate_to_model`) |\n| `query_trace` | Query execution traces for observability |\n| `query_task_state` | Query the structured task-state log for a task ID |\n| `get_job_result` | Read result of an async-mode dispatch by jobId (#3042 / #2631) |\n| `list_jobs` | List async-mode jobs across all tools — cross-session discovery (#3046 / #2631) |\n| `cancel_job` | Mark an async-mode job as cancelled — idempotent (#3042 Stage 1b) |\n| `ci_health_check` | CI infrastructure health — composes GitHub status + recent-runs activity (#3076) |\n| `verify_audit_chain` | Verify hash chain of a FileAuditStorage audit log directory |\n| `repo_analyze` | Analyze GitHub repository structure |\n| `repo_security_plan` | Generate security scanning pipeline for a repo |\n| `extract_symbols` | TypeScript-compiler-API AST symbols from a SINGLE file (functions/classes/types) |\n| `search_codebase` | Cross-file search over declared symbol NAMES (declarations only, not usages) |\n| `search_usages` | Structural usage/call-site search for a symbol via ast-grep (calls, member calls, new, imports, references) — the \"where is X used\" gap `search_codebase` cannot fill |\n| `run_dev_pipeline` | Full dev pipeline: research, plan, vote, implement, QA |\n| `run_pipeline` | Execute a pipeline plugin by name with typed input |\n| `pr_review` | Multi-voter PR review with verification gate (experimental) |\n| `supply_chain_tradeoff_panel` | Per-axis tradeoff vote for build-vs-buy / supply-chain decisions |\n| `improvement_review` | Threshold-gated observability loop — surfaces routing/tech-debt/bug/security signals from outcome+fitness data; files candidate issues |\n| `run_quality_gate` | Run the QA quality gate (typecheck/lint/tests/build/security) over a project dir; returns structured pass/fail verdict + feedback |\n| `suggest_research_tasks` | SUGGEST-ONLY: candidate pipeline tasks from research_discover findings for review — files/executes nothing (#1715) |\n| `list_available_models` | Probe all model-discovery transports (OpenRouter API + opencode/claude/codex/gemini CLIs) and report per-transport health — validates the CLIs/APIs are reachable (#3406) |\n| `run` | Default entry point — give a goal, MetaOrchestrator picks the strategy; returns the routing decision (execute:false, read-only) or runs it inline (execute:true; dev-pipeline+pipeline+research+consensus wired) (#3548) |\n\n\n\n---\n\n## Configuration\n\n**Environment Variables:**\n\n| Variable | Description |\n| ------------------- | --------------------------------- |\n| `ANTHROPIC_API_KEY` | Claude API key |\n| `OPENAI_API_KEY` | OpenAI API key |\n| `GOOGLE_AI_API_KEY` | Gemini API key |\n| `NEXUS_LOG_LEVEL` | Log level (debug/info/warn/error) |\n\n**Generate config file:**\n\n```bash\nnexus-agents config init # Creates nexus-agents.yaml\n```\n\n---\n\n## Documentation\n\n| Topic | Link |\n| ------------------ | ------------------------------------------------------------ |\n| Full CLI Reference | [docs/ENTRYPOINTS.md](./docs/ENTRYPOINTS.md) |\n| Architecture | [docs/architecture/README.md](./docs/architecture/README.md) |\n| Contributing | [CONTRIBUTING.md](./CONTRIBUTING.md) |\n| Coding Standards | [CODING_STANDARDS.md](./CODING_STANDARDS.md) |\n| Quick Start Guide | [QUICK_START.md](./QUICK_START.md) |\n\n---\n\n## Development\n\n```bash\ngit clone https://github.com/nexus-substrate/nexus-agents.git\ncd nexus-agents\npnpm install\npnpm build\npnpm test\n```\n\n**Requirements:** Node.js 22.x LTS, pnpm 9.x\n\n---\n\n## Contributing\n\n1. Fork the repository\n2. Create a feature branch (`git checkout -b feat/amazing-feature`)\n3. Commit with conventional commits (`feat(scope): add feature`)\n4. Open a Pull Request\n\nSee [CONTRIBUTING.md](./CONTRIBUTING.md) for details.\n\n---\n\n## License\n\nMIT - See [LICENSE](./LICENSE)\n\n---\n\nBuilt with Claude Code\n", "bytes": 37434, "sha": "fc9863a9a58e22f15ce55145cf579915613612e988447480a5596037e02552b5", "repo_slug": "williamzujkowski/nexus-agents", "fonte": "repo", "truncated": false, "api": "https://agentalog.com/api/listings/plg_williamzujkowski_nexus_agents_nexus_agen_b8ff1b58/readme" }