pluribus-context 0.3.40 → 0.3.42

package/examples/provider-degradation-canaries/check-degradation-receipt.mjs

@@ -0,0 +1,64 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+
+const args = process.argv.slice(2);
+const receiptPath = args[args.indexOf('--receipt') + 1];
+if (!receiptPath || args.indexOf('--receipt') === -1) {
+  console.error('Usage: node check-degradation-receipt.mjs --receipt <path>');
+  process.exit(2);
+}
+
+const receipt = JSON.parse(fs.readFileSync(receiptPath, 'utf8'));
+const errors = [];
+const gates = new Set(['continue', 'read_only', 'fallback_model', 'pause_writes', 'stop']);
+const confidences = new Set(['healthy', 'provider_degraded', 'app_bug', 'network', 'unknown']);
+
+function requireString(field) {
+  if (!receipt[field] || typeof receipt[field] !== 'string') errors.push(`${field} must be a non-empty string`);
+}
+
+if (receipt.schema !== 'pluribus.provider_degradation_decision.v1') {
+  errors.push('schema must be pluribus.provider_degradation_decision.v1');
+}
+for (const field of ['run_id', 'provider', 'model', 'region', 'prompt_template_hash', 'canary_suite_version']) {
+  requireString(field);
+}
+if (!String(receipt.prompt_template_hash || '').startsWith('sha256:')) {
+  errors.push('prompt_template_hash must be a sha256: digest');
+}
+if (!gates.has(receipt.write_gate)) errors.push(`write_gate must be one of ${[...gates].join(', ')}`);
+if (!confidences.has(receipt.confidence)) errors.push(`confidence must be one of ${[...confidences].join(', ')}`);
+
+const t = receipt.transport || {};
+for (const [field, limit] of Object.entries({ window_minutes: 1, ttft_p95_ms: 0, total_latency_p95_ms: 0, timeout_rate: 0, error_rate: 0, retry_count: 0 })) {
+  if (typeof t[field] !== 'number' || t[field] < limit) errors.push(`transport.${field} must be a number >= ${limit}`);
+}
+if (t.timeout_rate > 1 || t.error_rate > 1) errors.push('transport timeout/error rates must be <= 1');
+
+if (!Array.isArray(receipt.capability_canaries) || receipt.capability_canaries.length < 3) {
+  errors.push('capability_canaries must include at least three app-critical canaries');
+}
+const canaries = receipt.capability_canaries || [];
+const required = ['json_schema', 'tool_choice', 'patch_format'];
+for (const name of required) {
+  if (!canaries.some((c) => c.name === name)) errors.push(`missing required canary: ${name}`);
+}
+const failingWriteBlockers = canaries.filter((c) => c.status === 'fail' && c.severity === 'write_blocking');
+const degradedTransport = t.timeout_rate >= 0.05 || t.error_rate >= 0.05 || t.ttft_p95_ms >= 5000 || t.total_latency_p95_ms >= 30000;
+if (degradedTransport && receipt.confidence === 'healthy') {
+  errors.push('confidence cannot be healthy when transport degradation thresholds are exceeded');
+}
+if (failingWriteBlockers.length > 0 && ['continue'].includes(receipt.write_gate)) {
+  errors.push(`write_gate cannot be continue when write-blocking canaries fail: ${failingWriteBlockers.map((c) => c.name).join(', ')}`);
+}
+if (receipt.confidence === 'provider_degraded' && receipt.write_gate === 'continue' && !receipt.fallback?.chosen) {
+  errors.push('provider_degraded decisions must choose fallback or block writes instead of continue');
+}
+
+if (errors.length) {
+  console.error(`Degradation receipt failed (${receiptPath}):`);
+  for (const error of errors) console.error(`- ${error}`);
+  process.exit(1);
+}
+
+console.log(`Degradation receipt passed: ${receiptPath}`);

package/examples/provider-degradation-canaries/healthy-decision.json

@@ -0,0 +1,27 @@
+{
+  "schema": "pluribus.provider_degradation_decision.v1",
+  "run_id": "agent-run-2026-06-15T20:02Z",
+  "provider": "anthropic",
+  "model": "claude-sonnet-4",
+  "region": "us-east-1",
+  "prompt_template_hash": "sha256:7a6c7f8b4fb1f3a9d4d9325e5c2a9dbb6b4cbf2e77b49e1f69b1a8d93d1f5c22",
+  "canary_suite_version": "coding-agent-smoke-2026-06-15",
+  "transport": {
+    "window_minutes": 10,
+    "ttft_p95_ms": 1400,
+    "total_latency_p95_ms": 9200,
+    "timeout_rate": 0.01,
+    "error_rate": 0,
+    "retry_count": 1,
+    "status_incident_url": null
+  },
+  "capability_canaries": [
+    { "name": "json_schema", "status": "pass", "severity": "write_blocking" },
+    { "name": "tool_choice", "status": "pass", "severity": "write_blocking" },
+    { "name": "patch_format", "status": "pass", "severity": "write_blocking" },
+    { "name": "citation_grounding", "status": "pass", "severity": "review_blocking" }
+  ],
+  "fallback": { "chosen": false, "reason": null },
+  "confidence": "healthy",
+  "write_gate": "continue"
+}

package/examples/provider-degradation-canaries/unsafe-write-decision.json

@@ -0,0 +1,26 @@
+{
+  "schema": "pluribus.provider_degradation_decision.v1",
+  "run_id": "agent-run-2026-06-15T20:11Z",
+  "provider": "anthropic",
+  "model": "claude-sonnet-4",
+  "region": "us-east-1",
+  "prompt_template_hash": "sha256:7a6c7f8b4fb1f3a9d4d9325e5c2a9dbb6b4cbf2e77b49e1f69b1a8d93d1f5c22",
+  "canary_suite_version": "coding-agent-smoke-2026-06-15",
+  "transport": {
+    "window_minutes": 10,
+    "ttft_p95_ms": 6200,
+    "total_latency_p95_ms": 41000,
+    "timeout_rate": 0.18,
+    "error_rate": 0.08,
+    "retry_count": 12,
+    "status_incident_url": null
+  },
+  "capability_canaries": [
+    { "name": "json_schema", "status": "pass", "severity": "write_blocking" },
+    { "name": "tool_choice", "status": "fail", "severity": "write_blocking", "evidence": "selected shell write tool for read-only prompt" },
+    { "name": "patch_format", "status": "fail", "severity": "write_blocking", "evidence": "diff missing target file header" }
+  ],
+  "fallback": { "chosen": false, "reason": null },
+  "confidence": "provider_degraded",
+  "write_gate": "continue"
+}

package/examples/semantic-anchor-receipts/README.md

@@ -0,0 +1,49 @@
+# Semantic anchor preservation receipt
+
+A tiny checker for Claude Code / Agent Skill workflows that claim big token savings by cleaning pasted context before it enters a session.
+
+Token reduction is useful only if the cleaned paste keeps the anchors that make the task safe to execute: headings, code fences, API signatures, version/migration notes, and must-keep policy/security lines. This example emits a privacy-safe receipt for that claim without logging raw prompts or transcripts.
+
+## Run it
+
+```bash
+cd examples/semantic-anchor-receipts
+node check-semantic-anchors.mjs \
+  --original original-paste.md \
+  --cleaned cleaned-paste.md \
+  --out /tmp/semantic-anchor.receipt.json
+```
+
+The bundled sample should pass and report a token reduction while preserving all detected anchors.
+
+## Receipt shape
+
+```json
+{
+  "schema": "pluribus.semantic_anchor_preservation_receipt.v1",
+  "source_type": "paste-cleaning-skill-or-cli-output",
+  "approximate_tokens_before": 224,
+  "approximate_tokens_after": 110,
+  "approximate_reduction_percent": 50.9,
+  "anchors_total": 9,
+  "anchors_missing": 0,
+  "semantic_loss_check_passed": true,
+  "token_savings_claim_allowed": true
+}
+```
+
+The exact token counts are approximate. The important part is the gate:
+
+- `semantic_loss_check_passed=true` means the cleaned paste preserved the detected anchors.
+- `token_savings_claim_allowed=true` means the output both shrank and kept those anchors.
+- If any anchor is missing, the checker exits non-zero and the receipt records the missing anchor types/text snippets.
+
+## Why this exists
+
+The market signal has moved beyond MCP tool bloat. Claude Code users are also using Skills and paste-cleaning CLIs that claim 50–70% token savings. Pluribus should not be another optimizer; it should make the optimizer's claim falsifiable:
+
+- What was removed?
+- Which must-keep anchors survived?
+- Did a `SKILL.md` or CLI helper reduce tokens without deleting version, API, or security context?
+
+Use this receipt before a cleaned paste becomes session context. Pair it with tool/skill adoption receipts later if you need to prove the agent actually used a loaded Skill or MCP tool.

package/examples/semantic-anchor-receipts/check-semantic-anchors.mjs

@@ -0,0 +1,153 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+import path from 'node:path';
+
+function parseArgs(argv) {
+  const args = { out: null };
+  for (let i = 0; i < argv.length; i += 1) {
+    const key = argv[i];
+    const value = argv[i + 1];
+    if (key === '--original') { args.original = value; i += 1; continue; }
+    if (key === '--cleaned') { args.cleaned = value; i += 1; continue; }
+    if (key === '--out') { args.out = value; i += 1; continue; }
+    if (key === '--help' || key === '-h') { args.help = true; continue; }
+    throw new Error(`Unknown argument: ${key}`);
+  }
+  return args;
+}
+
+function usage() {
+  return `Usage: node check-semantic-anchors.mjs --original original-paste.md --cleaned cleaned-paste.md [--out receipt.json]\n`;
+}
+
+function normalize(value) {
+  return value
+    .replace(/`+/g, '')
+    .replace(/\s+/g, ' ')
+    .trim()
+    .toLowerCase();
+}
+
+function approxTokens(value) {
+  const chunks = value.trim().split(/\s+/).filter(Boolean).length;
+  return Math.max(1, Math.ceil(chunks * 1.33));
+}
+
+function extractAnchors(markdown) {
+  const anchors = [];
+  const lines = markdown.split(/\r?\n/);
+  let inFence = false;
+  let fenceLang = '';
+  let fenceLines = [];
+
+  function push(type, text, extra = {}) {
+    const canonical = normalize(text);
+    if (!canonical) return;
+    anchors.push({ type, text: text.trim(), canonical, ...extra });
+  }
+
+  for (const line of lines) {
+    const fence = line.match(/^```\s*([\w-]*)/);
+    if (fence) {
+      if (!inFence) {
+        inFence = true;
+        fenceLang = fence[1] || 'plain';
+        fenceLines = [];
+      } else {
+        const body = fenceLines.join('\n').trim();
+        if (body) push('code_fence', body, { language: fenceLang });
+        inFence = false;
+        fenceLang = '';
+        fenceLines = [];
+      }
+      continue;
+    }
+
+    if (inFence) {
+      fenceLines.push(line);
+      const sig = line.match(/\b(export\s+)?(async\s+)?(function|class|interface|type|def)\s+[A-Za-z0-9_]+[^;{]*/);
+      if (sig) push('api_signature', sig[0]);
+      continue;
+    }
+
+    if (/^#{1,4}\s+\S/.test(line)) push('heading', line.replace(/^#{1,4}\s+/, ''));
+    if (/\b(v?\d+\.\d+(?:\.\d+)?)\b/.test(line) && /\b(version|v\d|deprecated|removed|migration|upgrade|breaking|changed)\b/i.test(line)) {
+      push('version_or_migration_note', line);
+    }
+    if (/\b(never|must|do not|required|preserve|security|constraint)\b/i.test(line)) {
+      push('must_keep_policy', line.replace(/^[-*]\s+/, ''));
+    }
+    const sig = line.match(/\b(export\s+)?(async\s+)?(function|class|interface|type|def)\s+[A-Za-z0-9_]+[^;{]*/);
+    if (sig) push('api_signature', sig[0]);
+  }
+
+  const seen = new Set();
+  return anchors.filter((anchor) => {
+    const key = `${anchor.type}:${anchor.canonical}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+
+function main() {
+  const args = parseArgs(process.argv.slice(2));
+  if (args.help) { process.stdout.write(usage()); return; }
+  if (!args.original || !args.cleaned) throw new Error(usage().trim());
+
+  const originalPath = path.resolve(args.original);
+  const cleanedPath = path.resolve(args.cleaned);
+  const original = fs.readFileSync(originalPath, 'utf8');
+  const cleaned = fs.readFileSync(cleanedPath, 'utf8');
+  const cleanedCanonical = normalize(cleaned);
+  const anchors = extractAnchors(original);
+  const preserved = [];
+  const missing = [];
+
+  for (const anchor of anchors) {
+    const keep = cleanedCanonical.includes(anchor.canonical);
+    const compactAnchor = { type: anchor.type, text: anchor.text };
+    if (anchor.language) compactAnchor.language = anchor.language;
+    (keep ? preserved : missing).push(compactAnchor);
+  }
+
+  const before = approxTokens(original);
+  const after = approxTokens(cleaned);
+  const reduction = Number((((before - after) / before) * 100).toFixed(1));
+  const receipt = {
+    schema: 'pluribus.semantic_anchor_preservation_receipt.v1',
+    source_type: 'paste-cleaning-skill-or-cli-output',
+    original_ref: path.basename(originalPath),
+    cleaned_ref: path.basename(cleanedPath),
+    approximate_tokens_before: before,
+    approximate_tokens_after: after,
+    approximate_reduction_percent: reduction,
+    raw_source_logged: false,
+    anchor_detection_policy: [
+      'headings',
+      'code_fences',
+      'api_signatures',
+      'version_or_migration_notes',
+      'must_keep_policy_lines'
+    ],
+    anchors_total: anchors.length,
+    anchors_preserved: preserved.length,
+    anchors_missing: missing.length,
+    preserved_anchors: preserved,
+    missing_anchors: missing,
+    semantic_loss_check_passed: missing.length === 0,
+    token_savings_claim_allowed: missing.length === 0 && after < before
+  };
+
+  const serialized = `${JSON.stringify(receipt, null, 2)}\n`;
+  if (args.out) fs.writeFileSync(path.resolve(args.out), serialized);
+  process.stdout.write(serialized);
+  if (!receipt.semantic_loss_check_passed) process.exitCode = 1;
+}
+
+try {
+  main();
+} catch (error) {
+  console.error(error.message);
+  process.exit(1);
+}

package/examples/semantic-anchor-receipts/cleaned-paste.md

@@ -0,0 +1,17 @@
+# Upload API v2 migration notes
+
+The `uploadFile` helper changed in v2.4.0. Keep this version note because older snippets still use v1.
+
+```ts
+export async function uploadFile(input: UploadInput): Promise<UploadResult> {
+  return client.files.upload(input)
+}
+```
+
+## Required behavior
+
+- Preserve the retry policy: max 3 attempts with exponential backoff.
+- Do not strip the security constraint: never log raw file contents.
+- Deprecated: `uploadLegacy(path)` is removed after v2.5.0.
+
+Most verbose examples were removed, but the API signature, version notes, and security constraint survive.

package/examples/semantic-anchor-receipts/original-paste.md

@@ -0,0 +1,19 @@
+# Upload API v2 migration notes
+
+The `uploadFile` helper changed in v2.4.0. Keep this version note because older snippets still use v1.
+
+```ts
+export async function uploadFile(input: UploadInput): Promise<UploadResult> {
+  return client.files.upload(input)
+}
+```
+
+## Required behavior
+
+- Preserve the retry policy: max 3 attempts with exponential backoff.
+- Do not strip the security constraint: never log raw file contents.
+- Deprecated: `uploadLegacy(path)` is removed after v2.5.0.
+
+Most examples below are verbose and can be compressed before pasting into Claude Code once the important anchors are checked.
+
+Long example narrative: in staging we saw several users retry uploads manually after a network timeout, then paste screenshots and unrelated logs into the issue. The cleaned context does not need every anecdote, every repeated stack frame, or every copy of the same explanatory paragraph. It only needs enough surrounding language for the agent to understand the migration target after the anchors above are preserved. Remove repeated examples, duplicated support notes, and verbose operational chatter before the paste enters the session.

package/examples/semantic-anchor-receipts/sample-receipt.json

@@ -0,0 +1,62 @@
+{
+  "schema": "pluribus.semantic_anchor_preservation_receipt.v1",
+  "source_type": "paste-cleaning-skill-or-cli-output",
+  "original_ref": "original-paste.md",
+  "cleaned_ref": "cleaned-paste.md",
+  "approximate_tokens_before": 224,
+  "approximate_tokens_after": 110,
+  "approximate_reduction_percent": 50.9,
+  "raw_source_logged": false,
+  "anchor_detection_policy": [
+    "headings",
+    "code_fences",
+    "api_signatures",
+    "version_or_migration_notes",
+    "must_keep_policy_lines"
+  ],
+  "anchors_total": 9,
+  "anchors_preserved": 9,
+  "anchors_missing": 0,
+  "preserved_anchors": [
+    {
+      "type": "heading",
+      "text": "Upload API v2 migration notes"
+    },
+    {
+      "type": "version_or_migration_note",
+      "text": "The `uploadFile` helper changed in v2.4.0. Keep this version note because older snippets still use v1."
+    },
+    {
+      "type": "api_signature",
+      "text": "export async function uploadFile(input: UploadInput): Promise<UploadResult>"
+    },
+    {
+      "type": "code_fence",
+      "text": "export async function uploadFile(input: UploadInput): Promise<UploadResult> {\n  return client.files.upload(input)\n}",
+      "language": "ts"
+    },
+    {
+      "type": "heading",
+      "text": "Required behavior"
+    },
+    {
+      "type": "must_keep_policy",
+      "text": "## Required behavior"
+    },
+    {
+      "type": "must_keep_policy",
+      "text": "Preserve the retry policy: max 3 attempts with exponential backoff."
+    },
+    {
+      "type": "must_keep_policy",
+      "text": "Do not strip the security constraint: never log raw file contents."
+    },
+    {
+      "type": "version_or_migration_note",
+      "text": "- Deprecated: `uploadLegacy(path)` is removed after v2.5.0."
+    }
+  ],
+  "missing_anchors": [],
+  "semantic_loss_check_passed": true,
+  "token_savings_claim_allowed": true
+}

package/examples/session-preflight-receipts/README.md

@@ -0,0 +1,25 @@
+# Session preflight receipt example
+
+This example is for Cursor/Claude Code/MCP workflows where a project wants a required first step before agent work, such as `session_guard.session_init` or reading `MEMORY.md`.
+
+It turns a behavioral instruction into a reviewable artifact:
+
+1. The rule says the agent must initialize context first.
+2. The receipt records whether the required context was loaded.
+3. The decision says whether the run may proceed, must stay read-only, or should stop.
+
+Copy the sample rule into `.cursor/rules/session-preflight.mdc` and adapt the JSON fields to your local guard/MCP server.
+
+## Try it
+
+```bash
+node -e "const fs=require('fs'); const r=JSON.parse(fs.readFileSync('examples/session-preflight-receipts/session-preflight-receipt.json','utf8')); if (!r.decision.allowed_to_start_work) process.exit(1); console.log(r.schema, r.decision.mode)"
+```
+
+Expected output:
+
+```text
+pluribus.session_preflight_receipt.v1 read_then_patch
+```
+
+This does not enforce Cursor's tool calls by itself. It gives teams a concrete evidence object to ask for when evaluating required-first-tool or pre-tool-hook workflows.

package/examples/session-preflight-receipts/session-preflight-receipt.json

@@ -0,0 +1,39 @@
+{
+  "schema": "pluribus.session_preflight_receipt.v1",
+  "session_id": "local-2026-06-17T11:00Z",
+  "client": "cursor",
+  "required_first_step": {
+    "kind": "mcp_tool",
+    "name": "session_guard.session_init",
+    "enforcement": "behavioral_rule_only"
+  },
+  "required_context": [
+    {
+      "id": "project-memory",
+      "path": "MEMORY.md",
+      "status": "loaded",
+      "fingerprint": "sha256:replace-with-non-secret-digest"
+    },
+    {
+      "id": "project-rules",
+      "path": ".cursor/rules/session-preflight.mdc",
+      "status": "loaded",
+      "fingerprint": "sha256:replace-with-non-secret-digest"
+    }
+  ],
+  "tool_surface": {
+    "mcp_servers_seen": ["session-guard", "playwright"],
+    "side_effecting_tools_blocked_until_preflight": ["Shell", "Write"],
+    "read_only_tools_allowed_before_preflight": ["Read"]
+  },
+  "decision": {
+    "allowed_to_start_work": true,
+    "mode": "read_then_patch",
+    "reason": "required project memory and rules were checked before side-effecting tool use"
+  },
+  "privacy": {
+    "raw_context_logged": false,
+    "secrets_logged": false,
+    "fingerprints_only": true
+  }
+}

package/examples/session-preflight-receipts/session-preflight.mdc

@@ -0,0 +1,18 @@
+---
+description: Require a visible session preflight before side-effecting agent work.
+alwaysApply: true
+---
+
+Before using Shell, Write, Apply Patch, or external MCP tools, produce a session preflight receipt.
+
+The receipt must state:
+
+- required first step: `session_guard.session_init` or the local equivalent
+- required context files checked, such as `MEMORY.md`, `AGENTS.md`, `.cursor/rules/*.mdc`, or `CLAUDE.md`
+- whether only read-only tools are allowed before preflight
+- proceed mode: `read_only`, `read_then_patch`, `stop`, or `ask_human`
+- reason for the mode
+
+Do not paste raw memory or secrets into the receipt. Use status and non-secret fingerprints instead.
+
+If the preflight is missing or required context is unavailable, stay in `read_only` mode and ask for the missing context before edits.

package/examples/task-scoped-mcp-config/README.md

@@ -0,0 +1,60 @@
+# Task-scoped MCP config receipt
+
+A tiny demo for the Claude Code / MCP context-bloat complaint: MCP tools can consume context before they are used. One practical workaround is to keep a catalog of MCP server configs and start the agent with a task-specific `--mcp-config` instead of loading every server every time.
+
+This example makes that workaround auditable. It produces:
+
+1. a minimal Claude Code-compatible MCP config for one task; and
+2. a privacy-safe receipt showing which servers were selected, which were withheld, and why.
+
+It deliberately does **not** claim adoption. A selected MCP server is only agent-visible; a later tool-adoption receipt would still be needed to prove the agent called it.
+
+## Run it
+
+```bash
+cd examples/task-scoped-mcp-config
+node select-mcp-config.mjs \
+  --task tasks/browser-debug.json \
+  --out /tmp/browser-debug.mcp.json \
+  --receipt /tmp/browser-debug.receipt.json
+```
+
+Use the generated config with Claude Code or a compatible client:
+
+```bash
+claude --mcp-config /tmp/browser-debug.mcp.json
+```
+
+The demo catalog includes five plausible MCP servers. The `browser-debug` task selects only `playwright` and `context7`, withholding memory, observability, and repo-operation servers for the first pass.
+
+## Receipt shape
+
+The receipt is intentionally low-cardinality:
+
+```json
+{
+  "schema": "pluribus.task_scoped_mcp_config_receipt.v1",
+  "task_id": "browser-debug",
+  "selected_server_ids": ["playwright", "context7"],
+  "withheld_server_ids": ["sentry", "openmemory", "github"],
+  "selected_estimated_schema_tokens": 20000,
+  "withheld_estimated_schema_tokens": 24000,
+  "raw_tool_schemas_logged": false,
+  "adoption_claim_allowed": false
+}
+```
+
+Use it to review the initial context surface:
+
+- Did this task need every MCP server, or only a small subset?
+- Which server descriptions were kept out of the first context window?
+- Are we accidentally claiming “the agent used the tool” when we only proved “the tool was selected into the config”?
+
+## Why this exists
+
+The market signal is not “MCP is bad.” It is that large tool catalogs need two separate proofs:
+
+- **Surface proof:** which tools/servers were made visible for this task?
+- **Adoption proof:** which visible tools were actually called, cited, or used before claims/edits?
+
+This demo covers only the first proof. Pair it with a tool-adoption receipt when you need the second.

package/examples/task-scoped-mcp-config/mcp-catalog.json

@@ -0,0 +1,46 @@
+{
+  "schema": "pluribus.mcp_catalog.v1",
+  "catalogId": "demo-claude-code-mcp-catalog",
+  "servers": [
+    {
+      "id": "playwright",
+      "command": "npx",
+      "args": ["@playwright/mcp@latest"],
+      "category": "browser_automation",
+      "estimatedSchemaTokens": 11800,
+      "taskTags": ["browser", "web-debug", "e2e"]
+    },
+    {
+      "id": "context7",
+      "command": "npx",
+      "args": ["@upstash/context7-mcp@latest"],
+      "category": "docs_lookup",
+      "estimatedSchemaTokens": 8200,
+      "taskTags": ["docs", "api-reference"]
+    },
+    {
+      "id": "sentry",
+      "command": "npx",
+      "args": ["@sentry/mcp-server@latest"],
+      "category": "observability",
+      "estimatedSchemaTokens": 9700,
+      "taskTags": ["errors", "production-debug"]
+    },
+    {
+      "id": "openmemory",
+      "command": "npx",
+      "args": ["openmemory-mcp@latest"],
+      "category": "memory",
+      "estimatedSchemaTokens": 6900,
+      "taskTags": ["memory", "recall"]
+    },
+    {
+      "id": "github",
+      "command": "npx",
+      "args": ["@modelcontextprotocol/server-github@latest"],
+      "category": "repo_ops",
+      "estimatedSchemaTokens": 7400,
+      "taskTags": ["issues", "pull-requests", "repo"]
+    }
+  ]
+}