Server definition

Hash: sha256:27affe996afa3f8b77fde1511d1ccda098729b34c63b2f5a900bafdace303310
What it is: What a remote MCP server returned when asked what it offers: 7 tools

The blob, as servednamed by its sha256

{
  "instructions": "worklore is a library of short, honest developer stories that an agent can execute. Each story is something a real developer actually did — what they tried, what failed, what finally worked — paired with a machine-readable \"Reproduce this\" contract you can run in the user's own project, and a count of how many other people's agents reproduced it successfully.\n\nUse search_stories to find stories by topic, tag or stack. Use get_story to read one in full, including its reproduction contract. Use suggest_for_project when the user wants stories relevant to the code they are working on right now.\n\nUse check_capability to x-ray any skill, story or untrusted prompt text before running it: it returns a capability tier (T0-T4) bound to the content hash — what the content can actually touch, such as the network, the shell or the filesystem — plus behavioral red flags like prompt injection or exfiltration patterns.\n\nAfter reproducing a story, use report_reproduction to record honestly how it went; \"failed\" is a useful report and must never be inflated. Use publish_story to write up the user's own work — only ever with their explicit approval of the full draft. Use edit_story to revise a story the user wrote, after showing them a before/after diff and getting their approval; if something in it was wrong, record the edit as a correction with a note, which tells everyone who reproduced it.\n\nAlways read a story together with the user before acting on it.\n\nAuth: initialize, ping and tools/list answer with no credential at all, so directories, scanners and anyone curious can read what this server offers without an account. Every tools/call needs a signed-in session, and report_reproduction, publish_story and edit_story additionally act as the signed-in person. The list and the call are deliberately authorised differently; the reasoning is in the README under \"What answers without a token\".",
  "tools": [
    {
      "description": "Disclose what an agent Skill or worklore story CAN DO before you run it: a capability tier T0-T4 bound to a content sha256, with findings that carry file:line evidence, PLUS a separate list of behavioral red flags (prompt-injection / deception / exfiltration-intent / safety-bypass phrasings) for a human to review. This is blast-radius disclosure and triage, never a 'safe' verdict. Pass the raw `text`, or a `url` to fetch and scan (e.g. a worklore story .md).",
      "inputSchema": {
        "properties": {
          "text": {
            "description": "The skill/story text to scan.",
            "type": "string"
          },
          "url": {
            "description": "A URL to fetch and scan.",
            "type": "string"
          }
        },
        "type": "object"
      },
      "name": "check_capability",
      "outputSchema": {
        "properties": {
          "behavioral": {
            "items": {
              "properties": {
                "category": {
                  "type": "string"
                },
                "evidence": {
                  "type": "string"
                },
                "line": {
                  "anyOf": [
                    {
                      "type": "integer"
                    },
                    {
                      "type": "null"
                    }
                  ]
                },
                "why": {
                  "type": "string"
                }
              },
              "type": "object"
            },
            "type": "array"
          },
          "behavioral_note": {
            "type": "string"
          },
          "disclaimer": {
            "type": "string"
          },
          "endpoints": {
            "items": {
              "type": "string"
            },
            "type": "array"
          },
          "findings": {
            "items": {
              "properties": {
                "category": {
                  "type": "string"
                },
                "evidence": {
                  "type": "string"
                },
                "line": {
                  "anyOf": [
                    {
                      "type": "integer"
                    },
                    {
                      "type": "null"
                    }
                  ]
                },
                "severity": {
                  "type": "string"
                },
                "why": {
                  "type": "string"
                }
              },
              "type": "object"
            },
            "type": "array"
          },
          "scanner_version": {
            "type": "string"
          },
          "sha256": {
            "type": "string"
          },
          "tier": {
            "type": "string"
          },
          "tier_label": {
            "type": "string"
          }
        },
        "required": [
          "tier",
          "sha256"
        ],
        "type": "object"
      }
    },
    {
      "description": "Revise a worklore story the signed-in account PUBLISHED — only its author can edit it. Call get_story first, then show the human a before/after diff of your change and get their EXPLICIT approval before calling this; never edit on your own initiative. Send the COMPLETE revised story as `markdown` (frontmatter + '# title' + narrative + '## Reproduce this'), not a fragment. Keep the frontmatter `date` exactly as it is: it records when the work happened, and a revision never moves it. Say what kind of edit this is: 'rephrase' (same claims, better wording), 'addition' (new detail, nothing was wrong), or 'correction' (something in the story was WRONG — a step, a claim, a result). If anything was wrong, it is a correction: never hide a correction as a rephrase. A correction requires a one-line `note` saying what was wrong, and notifies everyone who reported reproducing the story. `source` optionally credits what prompted the revision (an https URL). The new text REPLACES the old (worklore keeps no copy of earlier text), while a record of this revision — when, what kind, the note — is appended to the story's public history.",
      "inputSchema": {
        "properties": {
          "kind": {
            "default": "rephrase",
            "description": "rephrase (default) — same claims, reworded; addition — new detail, nothing was wrong; correction — something was wrong (requires `note`, notifies reproducers).",
            "enum": [
              "rephrase",
              "addition",
              "correction"
            ],
            "type": "string"
          },
          "markdown": {
            "description": "The complete revised story markdown, frontmatter included, with the original `date` unchanged.",
            "type": "string"
          },
          "note": {
            "description": "One line on what changed (max 500 chars). Required for a correction: what was wrong.",
            "type": "string"
          },
          "slug": {
            "description": "The slug of the story to revise (one the signed-in account wrote).",
            "type": "string"
          },
          "source": {
            "description": "Optional https URL crediting what prompted the revision (a comment, an issue, an article).",
            "type": "string"
          }
        },
        "required": [
          "slug",
          "markdown"
        ],
        "type": "object"
      },
      "name": "edit_story",
      "outputSchema": {
        "additionalProperties": false,
        "properties": {
          "notified": {
            "type": "integer"
          },
          "revision": {
            "additionalProperties": false,
            "properties": {
              "at": {
                "type": "string"
              },
              "kind": {
                "enum": [
                  "rephrase",
                  "addition",
                  "correction"
                ],
                "type": "string"
              },
              "note": {
                "type": "string"
              },
              "source": {
                "type": "string"
              }
            },
            "required": [
              "at",
              "kind"
            ],
            "type": "object"
          },
          "slug": {
            "type": "string"
          },
          "url": {
            "type": "string"
          },
          "visibility": {
            "type": "string"
          }
        },
        "required": [
          "slug",
          "url",
          "revision",
          "notified"
        ],
        "type": "object"
      }
    },
    {
      "description": "Fetch one worklore story by slug — its full markdown (narrative + the 'Reproduce this' contract your agent would run) WITH its capability disclosure attached (tier + findings), so you see what it can do before applying it. Read the capability first; run check_capability on the live artifacts before executing. After you apply the story to the user's task, call report_reproduction with an honest result to record it.",
      "inputSchema": {
        "properties": {
          "slug": {
            "description": "The story slug (from search_stories / a worklore URL).",
            "type": "string"
          }
        },
        "required": [
          "slug"
        ],
        "type": "object"
      },
      "name": "get_story",
      "outputSchema": {
        "properties": {
          "after_you_apply_this": {
            "type": "string"
          },
          "capability": {
            "type": "object"
          },
          "markdown": {
            "type": "string"
          },
          "slug": {
            "type": "string"
          },
          "title": {
            "type": "string"
          },
          "unavailable": {
            "type": "string"
          },
          "visibility": {
            "type": "string"
          },
          "visibility_note": {
            "type": "string"
          }
        },
        "required": [
          "slug"
        ],
        "type": "object"
      }
    },
    {
      "description": "Publish a NEW worklore story as the signed-in account. worklore stories are PUBLIC and honest, so before you call this you MUST show the human the complete draft — the title, the first-person narrative, and the 'Reproduce this' contract — and get their EXPLICIT approval. Never publish on your own initiative and never invent details. Provide the full story as `markdown` (frontmatter with title/date/tags/type/reproducible, then '# title', the narrative, then '## Reproduce this' with prerequisites/inputs/steps/verify) — call get_story on an existing story first to match the format — OR provide the structured fields title + narrative (+ reproduce, tags, type, stack) and the server assembles it. SANITIZE: no secrets, employer internals, client names, or private URLs. Returns the live URL and capability tier.",
      "inputSchema": {
        "properties": {
          "markdown": {
            "description": "The complete story markdown (frontmatter + '# title' + narrative + '## Reproduce this' contract). Preferred.",
            "type": "string"
          },
          "narrative": {
            "description": "First-person narrative, ~150-400 words, honest (used if no `markdown`).",
            "type": "string"
          },
          "reproduce": {
            "description": "The 'Reproduce this' contract body: prerequisites, inputs, ordered steps, verify.",
            "type": "string"
          },
          "stack": {
            "description": "Optional: the ecosystem this story is about.",
            "type": "string"
          },
          "tags": {
            "description": "3-6 lowercase kebab tags.",
            "items": {
              "type": "string"
            },
            "type": "array"
          },
          "title": {
            "description": "Story title (used only if `markdown` is not given).",
            "type": "string"
          },
          "type": {
            "description": "success (default), fail, or proposal — a proposal is work the author believes is right but cannot prove yet, published to get evidence or review rather than to claim a result.",
            "enum": [
              "success",
              "fail",
              "proposal"
            ],
            "type": "string"
          },
          "visibility": {
            "description": "public (default) — anyone can read and reproduce it; private — only the author can, and it appears in no feed, search, badge or link. Ask the human which they want if the draft contains anything they may not want public.",
            "enum": [
              "public",
              "private"
            ],
            "type": "string"
          }
        },
        "type": "object"
      },
      "name": "publish_story",
      "outputSchema": {
        "properties": {
          "capability": {
            "type": "object"
          },
          "similar": {
            "type": "array"
          },
          "slug": {
            "type": "string"
          },
          "url": {
            "type": "string"
          }
        },
        "type": "object"
      }
    },
    {
      "description": "Call this right after you apply a worklore story's steps to the user's own task, to record the reproduction (attributed to the signed-in account). Use an honest result: 'worked', 'partial' (you produced the output but it isn't verified yet), or 'failed' — all are useful. One counted report per person per story; repeats are acknowledged, not doubled. Never report a story you did not apply.",
      "inputSchema": {
        "properties": {
          "note": {
            "description": "Optional short note (max 500 chars).",
            "type": "string"
          },
          "result": {
            "description": "How it honestly went.",
            "enum": [
              "worked",
              "partial",
              "failed"
            ],
            "type": "string"
          },
          "slug": {
            "description": "The story slug you reproduced.",
            "type": "string"
          }
        },
        "required": [
          "slug",
          "result"
        ],
        "type": "object"
      },
      "name": "report_reproduction",
      "outputSchema": {
        "properties": {
          "counted": {
            "type": "boolean"
          },
          "credited": {
            "type": "string"
          },
          "ok": {
            "type": "boolean"
          },
          "thanks": {
            "type": "string"
          }
        },
        "type": "object"
      }
    },
    {
      "description": "Search worklore stories by keyword across title, summary, tags and stack. Returns matches with their capability tier.",
      "inputSchema": {
        "properties": {
          "query": {
            "description": "Keywords (space-separated; all must match).",
            "type": "string"
          }
        },
        "type": "object"
      },
      "name": "search_stories",
      "outputSchema": {
        "properties": {
          "about_tiers": {
            "type": "string"
          },
          "count": {
            "type": "integer"
          },
          "query": {
            "type": "string"
          },
          "stories": {
            "items": {
              "properties": {
                "capability": {
                  "anyOf": [
                    {
                      "type": "string"
                    },
                    {
                      "type": "null"
                    }
                  ]
                },
                "slug": {
                  "type": "string"
                },
                "stack": {
                  "anyOf": [
                    {
                      "type": "string"
                    },
                    {
                      "type": "null"
                    }
                  ]
                },
                "summary": {
                  "anyOf": [
                    {
                      "type": "string"
                    },
                    {
                      "type": "null"
                    }
                  ]
                },
                "tags": {
                  "anyOf": [
                    {
                      "type": "array"
                    },
                    {
                      "type": "null"
                    }
                  ]
                },
                "tier": {
                  "anyOf": [
                    {
                      "type": "string"
                    },
                    {
                      "type": "null"
                    }
                  ]
                },
                "title": {
                  "anyOf": [
                    {
                      "type": "string"
                    },
                    {
                      "type": "null"
                    }
                  ]
                },
                "visibility": {
                  "anyOf": [
                    {
                      "type": "string"
                    },
                    {
                      "type": "null"
                    }
                  ]
                }
              },
              "type": "object"
            },
            "type": "array"
          }
        },
        "required": [
          "stories"
        ],
        "type": "object"
      }
    },
    {
      "description": "Given a short description of the current project (stack, what you're building, recent problems), suggest up to 3 worklore stories worth reproducing here, with why each fits and its tier.",
      "inputSchema": {
        "properties": {
          "context": {
            "description": "Project context: stack, goal, recent TODOs/problems.",
            "type": "string"
          }
        },
        "required": [
          "context"
        ],
        "type": "object"
      },
      "name": "suggest_for_project",
      "outputSchema": {
        "properties": {
          "about_tiers": {
            "type": "string"
          },
          "note": {
            "type": "string"
          },
          "suggested": {
            "items": {
              "properties": {
                "capability": {
                  "anyOf": [
                    {
                      "type": "string"
                    },
                    {
                      "type": "null"
                    }
                  ]
                },
                "slug": {
                  "type": "string"
                },
                "stack": {
                  "anyOf": [
                    {
                      "type": "string"
                    },
                    {
                      "type": "null"
                    }
                  ]
                },
                "tier": {
                  "anyOf": [
                    {
                      "type": "string"
                    },
                    {
                      "type": "null"
                    }
                  ]
                },
                "title": {
                  "anyOf": [
                    {
                      "type": "string"
                    },
                    {
                      "type": "null"
                    }
                  ]
                },
                "why": {
                  "type": "string"
                }
              },
              "type": "object"
            },
            "type": "array"
          }
        },
        "required": [
          "suggested"
        ],
        "type": "object"
      }
    }
  ]
}

Verify it yourself

curl -s https://api.teppi.xyz/v1/evidence/sha256:27affe996afa3f8b77fde1511d1ccda098729b34c63b2f5a900bafdace303310 | sha256sum