# humanMCP — kapoost

> Personal MCP server for humans who create. Proof of authorship, license control.

- name: io.github.kapoost/humanmcp
- version: 0.3.0
- connection class: R0 (autonomous)
- trust: 87/100
- quality: 83/100 (good)
- owner: not claimed
- descriptor: https://api.protogrid.dev/v1/servers/io.github.kapoost%2Fhumanmcp
- tools: https://api.protogrid.dev/v1/servers/io.github.kapoost%2Fhumanmcp/tools

**An agent can connect right now, no human step.** Remote endpoint, no authentication, reachable on the last probe.

## Connection (mcpServers)

```json
{
  "mcpServers": {
    "humanmcp": {
      "type": "http",
      "url": "https://kapoost.humanmcp.net/mcp"
    }
  }
}
```


## Trust

- hygiene: 100
- liveness: 100
- freshness: 65
- provenance: 80
- drivers: +repository +namespace-matches-repo +reachable +uptime-99% ~updated-168d-ago
- Derived from observable signals (official registry feed and our own credential-free probes); no code audit performed.

## Quality 83/100 (good)

### protocol: 88 (weight 25)

- pass `protocol.modern`: supports 2026-07-28 (server/discover)
- pass `protocol.stateless`: answers without a session
- pass `protocol.transport`: streamable HTTP
- warn `protocol.list_ttl`: tools/list declares ttlMs 0, so clients re-fetch it on every use

### authorization: n/a (weight 15)

- n/a `auth.prm`, `auth.as_metadata`, `auth.cimd`: no remote uses OAuth
- n/a `auth.secret_in_url`: no templated URL

### tool hygiene: 71 (weight 30)

- pass `tools.descriptions`: every tool has a description
- pass `tools.description_length`: descriptions are concise
- pass `tools.schemas`: every tool has an object input schema
- fail `tools.annotations`: no tool declares readOnlyHint or destructiveHint, so clients cannot tell safe calls from risky ones
- fail `tools.directory_hints`: no tool declares all four of readOnlyHint, destructiveHint, idempotentHint and openWorldHint; missing: get_skill (readOnlyHint, destructiveHint, idempotentHint, openWorldHint); list_provenance (readOnlyHint, destructiveHint, idempotentHint, openWorldHint); get_author_profile (readOnlyHint, destructiveHint, idempotentHint, openWorldHint); …
- pass `tools.token_cost`: about 3,771 tokens to load every tool
- pass `tools.api_dump`: tools are not a one-to-one API dump

### stability: 100 (weight 15)

- pass `stability.changes`: no tool changes in 30 days
- pass `stability.rug_pull`: no tool changed its meaning under the same name

### dependencies: n/a (weight 15)

- n/a `deps.known_vulns`, `deps.mcp_sdk_version`, `deps.resolvable`: no npm or PyPI package

- tools: 43, about 3,771 tokens to load them all
- tool set hash: 3e768c16bb83d1b3ec5b3351ad82e779
- badge: [![protogrid quality](https://protogrid.dev/badge/io.github.kapoost/humanmcp.svg)](https://protogrid.dev/servers/io.github.kapoost/humanmcp)
- Checks run on what our credential-free, read-only probes observe; tools are never called and no code audit is performed.

### Tool changes

_No tool definition changes recorded._

## Remotes

- https://kapoost.humanmcp.net/mcp (streamable-http, auth none, reachable true, uptime30d 0.99159664)

## Packages

_none_

## Tools (43)

- `about_humanmcp`: Self-description of this humanMCP server. Deterministic, no bootstrap required — call this first to decide whether the rest of the API is relevant.
- `ask_human`: Submit an async question to kapoost. Returns an ID. Rate-limited 5/hr/IP. Poll fetch_answer later — kapoost answers on his own schedule (minutes, hours, or days). ALWAYS set `from` to a stable name for yourself: with it, sending the same question again returns the answer instead of creating a duplicate, which is the reliable path when your runtime cannot keep the ID between sessions.
- `bootstrap_session`: Validate the Polish poetry session code, then emit the full team briefing (guardian + style + personas + skills + persist block). Rate-limited 5/min/IP.
- `delete_skill`: Delete a skill by slug. Owner-only: requires Authorization: Bearer <token>.
- `fetch_answer`: Poll for an answer to an ask_human question. Marks the question as fetched the first time an answer is returned. Rate-limited 30/hr/IP.
- `fetch_narada_result`: Poll a narada job by ID. Statuses: pending, running, done, failed. When done, returns all persona voices.
- `get_author_profile`: Author identity, bio, and a browsing cheatsheet. Records a profile-view event.
- `get_certificate`: Return a formatted copyright/authenticity certificate for a piece.
- `get_persona`: Return one persona's full prompt by slug. Session-gated except for Hodor (guardian rules must always apply). Pass session_token if your client cannot set an Authorization header.
- `get_persona_journal`: Read a persona's raw reflection journal. Owner-only — the journal is a private feedback loop, not for external callers.
- `get_skill`: Return one skill's full body by slug. Session-gated except for -public suffixed skills (guardian bypass). Pass session_token if your client cannot set an Authorization header.
- `leave_comment`: Attach a short comment (≤280 chars) to a piece kapoost has published. Truncated silently past the limit.
- `leave_message`: Send kapoost a longer message. context REQUIRED (why you're writing / which piece / which task). contact optional — without it no reply is possible.
- `list_blobs`: List typed data artifacts (images, contact, vectors, documents, datasets, capsules). Filter by blob_type. Readable-column reflects caller_kind + caller_id vs audience.
- `list_collection`: List works kapoost owns but did NOT create. Public items always; members-only surface only after session activation.
- `list_content`: List published pieces (slug, title, type, access, tags). Optional type/tag filters.
- `list_personas`: List every persona (slug, title, role). Full prompts unlock after bootstrap_session.
- `list_provenance`: List provenance items (chain of custody, certificates, invoices) for an artwork slug. Tries piece then collection.
- `list_skill_groups`: Index of every skill tag in use, with slugs per group. Public — no bootstrap required.
- `list_skills`: List skills (slug, category, title, tags). Optional category / tag filters.
- `load_skill_group`: Bulk-fetch every skill tagged with the given group name. Respects the bootstrap gate per-skill: -public suffix bypasses, everything else needs session.
- `mysloodsiewnia_get`: Fetch one document from kapoost's vault by slug. Requires Authorization: Bearer <edit token or friend token>. Friend tokens: vault-side filter enforces scope + access:private invisibility — an out-of-scope or private slug returns not_found. Vault offline ⇒ {status:offline}.
- `mysloodsiewnia_list`: Enumerate vault documents without FTS — for browsing by type or paginating. Requires Authorization: Bearer <edit token or friend token>. Friend tokens see only their scoped doc_types; access:private is invisible. Args: {doc_type?: string filter (note/pdf/literatura/calendar_event/...), limit?: int 1-200 default 50, offset?: int default 0}. Returns [{slug, title, doc_type, created_at, chunk_count}]. Vault offline ⇒ {status:offline}.
- `mysloodsiewnia_search`: Full-text search (BM25 over SQLite FTS5) on kapoost's local vault corpus. Requires Authorization: Bearer <edit token or friend token>. Friend tokens see only their scoped doc_types; access:private is invisible. Returns {status, results:[{source, type, body, doc_slug, title, page, citation}], summary}. Vault offline ⇒ {status:offline}.
- `mysloodsiewnia_status`: Read-only liveness probe on kapoost's local vault (mysłoodsiewnia). Returns {status: online|degraded|offline, last_seen, commit_sha, personas_updated_at, skills_updated_at}. Offline is a stable state — retry later, don't escalate. Requires Authorization: Bearer <edit token or friend token>.
- `mysloodsiewnia_write`: Ingest a new document into kapoost's vault (wave 2). OWNER-ONLY — friend tokens receive {status:write_denied,reason:owner_only}. Args: {doc_type (required), title (required), body (required, ≤100 KiB), source_path?, meta?}. Requires Authorization: Bearer <owner token>. On Unauthorized: obtain the token by either (a) calling bootstrap_session(code=<owner poet fragment>) and reading SESSION_TOKEN from the response briefing (1h TTL, preferred for agents that already know the code), or (b) if you have shell access on kapoost's Mac, running `security find-generic-password -s humanmcp-edit-token -w` to fetch the persistent EDIT_TOKEN. Server-side vault auto-tags via:humanmcp-bridge; op_id is dedup key (idempotent retries safe). Delete is permanently unavailable. Envelopes: {status:online, op_id, result:{slug, created_at}}, {status:invalid_args}, {status:payload_too_large, limit, got}, {status:offline}, {status:vault_timeout}, {status:vault_error, error}.
- `prepare_narada`: Offline narada: returns the panel plus each persona's ready-to-run SYSTEM/USER prompts so YOU run them as your own subagents, instead of the server generating voices. No LLM cost, no rate limit, nothing recorded — no narada ID and no journal feedback. Prefer this over run_narada when your subagents can read material the server cannot (a repository, local files) or when the server has no API key. Session-gated.
- `read_blob`: Read one blob by slug. Returns text or base64-encoded data. Access-gated by audience unless blob is public.
- `read_collection_item`: Full record for one collection item + dossier count. Access-gated: private is never visible, members needs session.
- `read_content`: Read a public piece by slug. Locked pieces return a hint pointing at request_access.
- `read_provenance`: Return one provenance item with resolvable file URLs. slug + id required.
- `recall`: List memories saved under the given code, optionally substring-filtered by query. Session-gated for symmetry with remember.
- `record_persona_reflection`: Ask a persona to write a lesson-for-self after a rolled-back narada recommendation. Appends to the persona's journal via Sonnet/Haiku. Owner-only.
- `remember`: Persist a note under the given session code. Session-gated — bootstrap_session first. Callers sharing the code share the memory.
- `request_access`: Get the gate details for a locked piece: challenge question, manual-review flow, time-lock countdown, payment terms, or trade rules.
- `request_license`: Declare intended use of a piece, get licensing terms + audit-log entry. caller_id is REQUIRED (whitespace-only rejected — storyboard-pinned).
- `run_narada`: Create an async narada job: server routes context to 3-5 personas via keyword manifest, then generates each voice via Sonnet 4.6 (Haiku 4.5 for journal recaps). Returns job ID for polling. Pass `personas` to pick the voices yourself and skip the router entirely — the router matches keywords only and cannot read a request to include or exclude someone written in the context.
- `search_content`: Search kapoost's pieces by words in title, tags, description and body. Every word must match (AND). Polish diacritics are folded, so "czlowieczenstwa" finds "człowieczeństwa". Use this BEFORE ask_human — most questions about which piece is which are answered here instantly, while ask_human waits for a human. Locked pieces are matched by title and tags only; their body is never searched or quoted.
- `submit_answer`: Submit an answer to a challenge-gated piece. Correct answer unlocks and returns the full body.
- `suggest_skills`: Deterministic manifest→tag mapping. Given files + languages + git_origin, returns up to 8 skill slugs and up to 5 personas, each with the reason it fired. No LLM classification.
- `synthesise_persona_patterns`: Force-run Sonnet synthesis over a persona's raw journal, replacing the previous pattern set. Owner-only — paid + writes internal state.
- `upsert_skill`: Create or replace a skill by slug. Owner-only: requires Authorization: Bearer <token>. Writes JSON to content/skills/<slug>.json.
- `verify_content`: Verify a piece's Ed25519 signature against the server's owner public key.