loopctl-mcp-server 2.33.1 → 2.35.0

package/README.md

@@ -2,7 +2,7 @@
 
 MCP (Model Context Protocol) server for [loopctl](https://loopctl.com) -- structural trust for AI development loops.
 
-Wraps the loopctl REST API into 72 typed MCP tools so AI coding agents (Claude Code, etc.) can interact with loopctl without writing curl commands.
+Wraps the loopctl REST API into 73 typed MCP tools so AI coding agents (Claude Code, etc.) can interact with loopctl without writing curl commands.
 
 ## Installation
 
@@ -62,12 +62,66 @@ Or if installed locally:
 | `LOOPCTL_API_KEY` | Global API key override (if set, always used) | -- |
 | `LOOPCTL_ORCH_KEY` | Orchestrator role API key (verify, reject, review, import) | -- |
 | `LOOPCTL_AGENT_KEY` | Agent role API key (contract, claim, start, request-review) | -- |
-| `LOOPCTL_USER_KEY` | User role API key. Required ONLY for destructive admin tools like `knowledge_bulk_publish`. Leave unset if you don't use those tools. | -- |
+| `LOOPCTL_USER_KEY` | User role API key (minted at signup). Required for **first-time BYO LLM key provisioning** (`set_llm_config` / `llm_config` — see [First-time setup](#first-time-setup--provision-your-byo-llm-keys)) and for destructive admin tools like `knowledge_bulk_publish`. | -- |
 | `LOOPCTL_STH_STATE_PATH` | Absolute path for the witness-protocol STH cache file (see [Witness protocol](#witness-protocol-sth)). Optional. | per-(server + key) file under the OS temp dir |
 
 Key resolution priority: `LOOPCTL_API_KEY` > tool-specific key > `LOOPCTL_ORCH_KEY`.
 
-## Tools (72)
+## First-time setup — provision your BYO LLM keys
+
+**loopctl is agent-native and strictly BYO (bring-your-own-keys).** loopctl fronts
+**no** LLM cost — the knowledge wiki runs entirely on *your* provider keys, which you
+provision once and which bill you directly. Two SEPARATE keys power two capabilities:
+
+| Key | Provider | Powers | Missing ⇒ |
+|---|---|---|---|
+| `api_key` | Anthropic | knowledge **ingest** — extraction, classification, merge synthesis | `knowledge_ingest` returns **422** (`code: no_api_key`) |
+| `embedding_api_key` | OpenAI-compatible | article **embeddings + semantic search** | `knowledge_search` silently degrades to **keyword-only** (`meta.fallback_reason: no_embedding_key`) |
+
+Both keys are stored **encrypted** and are **never returned** by any tool. You can set
+per-operation model overrides (`extraction_model`, `classification_model`,
+`merge_model`, `embedding_model`); each defaults server-side when omitted.
+
+### The smooth path (once, at onboarding)
+
+1. **Sign up** and obtain your keys. loopctl has two trust tiers (US-26.7.1):
+   - **Human-anchored (unlocks work-breakdown / chain-of-custody too):** visit
+     `https://loopctl.com/signup` and enroll a hardware authenticator (WebAuthn) —
+     the one human touch. This mints your **user-role** API key; also grab your
+     **agent** and **orchestrator** keys for day-to-day work.
+   - **Agent-rooted (KB-tier only, fully automated):** call the `signup` MCP tool
+     (or `POST /api/v1/signup` directly) with `name`/`slug`/`email` — no human, no
+     hardware key. This mints a one-time `role: user` API key with the FULL
+     knowledge-wiki surface (ingest/search/curate, BYO LLM config, agent
+     registration), but it **cannot** perform work-breakdown / chain-of-custody
+     operations. The `raw_key` in the response is shown ONCE — save it
+     immediately (it cannot be retrieved again).
+2. **Set the env** in your `.mcp.json` (see [Configuration](#configuration)):
+   `LOOPCTL_SERVER`, `LOOPCTL_USER_KEY` (needed for this step), plus `LOOPCTL_AGENT_KEY`
+   / `LOOPCTL_ORCH_KEY`.
+3. **Provision both keys in one call** (uses `LOOPCTL_USER_KEY`):
+
+   ```
+   set_llm_config({ api_key: "sk-ant-...", embedding_api_key: "sk-..." })
+   ```
+
+   Partial-merge: you can set or rotate one key at a time; omitting a key leaves the
+   existing one untouched. Optionally pass model overrides in the same call.
+4. **You're live.** `knowledge_ingest` extracts articles and `knowledge_search`
+   (combined/semantic) ranks by meaning. Check status anytime with
+   `llm_config` (reports `has_api_key` / `has_embedding_key` + masked last-4 hints,
+   never the key).
+
+### Self-healing: you can't get stuck
+
+If you call `knowledge_ingest` or `knowledge_search` **before** provisioning, the
+tool result **leads with an `ACTION REQUIRED` notice** and a machine-readable
+`remediation` object — naming the `set_llm_config` tool, a copy-paste example, the
+REST endpoint (`PATCH /api/v1/tenants/me/llm-config`), and the docs — so you (or an
+autonomous agent) can self-remediate without a human. Full agent-tenant lifecycle:
+[`docs/onboarding-agent-tenant.md`](../docs/onboarding-agent-tenant.md).
+
+## Tools (73)
 
 ### Project Tools
 
@@ -177,7 +231,7 @@ Key resolution priority: `LOOPCTL_API_KEY` > tool-specific key > `LOOPCTL_ORCH_K
 | `knowledge_drafts` | List draft (unpublished) knowledge articles with pagination. Optional: `limit` (default 20, max 1000 — over-max → 400, no silent clamp), `offset` (default 0), `project_id`. Returns `meta.total_count`. |
 | `knowledge_lint` | Run a lint check on the knowledge wiki to identify stale or low-coverage articles. Optional: `project_id`, `stale_days`, `min_coverage`, `max_per_category` (default 50, max 500). True totals returned in `summary.total_per_category`. |
 | `knowledge_export` | Export all knowledge articles as an OKF v0.1 bundle (gzipped tar archive, unbounded, bounded-memory streaming, fail-closed). Returns a curl command for direct download — **the download requires `LOOPCTL_USER_KEY`** (an orchestrator key would 403). Pass `format=json` for buffered in-memory JSON (convenience tool for file writers; capped at `export_max_buffered_export_articles` — returns 413 if over-cap). Optional: `project_id`, `format` (`tar.gz` default or `json`). |
-| `knowledge_ingest` | Submit a URL or raw content for knowledge extraction. Enqueues an Oban job. Extracted articles are **drafts by default** (lower-trust LLM output); pass `publish: true` to publish on extraction. Required: `source_type`. One of: `url` or `content`. Optional: `project_id`, `publish`. |
+| `knowledge_ingest` | Submit a URL or raw content for knowledge extraction. Enqueues an Oban job. Extracted articles are **drafts by default** (lower-trust LLM output); pass `publish: true` to publish on extraction. **BYO:** runs on the tenant's own Anthropic key — a keyless tenant gets a 422 whose result leads with an `ACTION REQUIRED` notice pointing at `set_llm_config` (see [First-time setup](#first-time-setup--provision-your-byo-llm-keys)). Required: `source_type`. One of: `url` or `content`. Optional: `project_id`, `publish`. |
 | `knowledge_ingest_batch` | Submit up to 50 ingestion items in a single request. Each item has the same shape as `knowledge_ingest` (incl. `publish`). Returns per-item results. Required: `items`. Optional: batch-level `project_id` / `publish` defaults. |
 | `knowledge_ingestion_jobs` | List recent content ingestion jobs (last 7 days, max 50). |
 
@@ -185,8 +239,8 @@ Key resolution priority: `LOOPCTL_API_KEY` > tool-specific key > `LOOPCTL_ORCH_K
 
 | Tool | Description |
 |---|---|
-| `llm_config` | Get the tenant's BYO Anthropic LLM config: per-operation models, `has_api_key`, and a masked last-4 hint. Never returns the key. Requires **user** key. |
-| `set_llm_config` | Set/rotate the tenant's OWN Anthropic API key (stored encrypted, never returned) + the three per-operation models (`extraction_model`/`classification_model`/`merge_model`). Any subset; omitting `api_key` leaves it untouched. Requires **user** key. |
+| `llm_config` | **Check your onboarding status.** Get the tenant's BYO LLM config: per-operation models and whether each key is set — `has_api_key` (Anthropic) / `has_embedding_key` (OpenAI embedding) — plus masked last-4 hints. Never returns a key. Requires **user** key. |
+| `set_llm_config` | **First-time setup (do once).** Set/rotate the tenant's OWN **Anthropic `api_key`** (powers ingest) AND **OpenAI `embedding_api_key`** (powers semantic search) — both stored encrypted, never returned — plus the per-operation models (`extraction_model`/`classification_model`/`merge_model`/`embedding_model`). Any subset; partial-merge (omitting a key leaves it untouched). See [First-time setup](#first-time-setup--provision-your-byo-llm-keys). Requires **user** key. |
 | `knowledge_llm_usage` | Per-tenant LLM token-usage summary, grouped by operation + model + source_type + day over an optional `from`/`to` range (defaults to a 90-day lookback; effective window echoed in `meta.from`/`meta.to`), with `limit`/`offset` pagination. Record-only (no budget enforcement). Requires orchestrator key. |
 
 ### Knowledge Analytics Tools (orchestrator key)
@@ -213,6 +267,7 @@ Key distribution for the dispatch pattern (Epic 26): per-dispatch ephemeral keys
 
 | Tool | Description |
 |---|---|
+| `signup` | **US-26.7.1.** Create a NEW **agent-rooted (KB-tier)** tenant and mint its one-time root API key — entirely through this call, no human operator, no hardware authenticator, no existing API key required. The tenant gets the FULL knowledge-wiki surface but **cannot** perform work-breakdown / chain-of-custody operations (those require a separate human-anchored tenant via the WebAuthn ceremony at `https://loopctl.com/signup`). Rate-limited per client IP (<= 5/hour). The `raw_key` is shown ONCE — save it immediately (e.g. as `LOOPCTL_USER_KEY`). Required: `name`, `slug`, `email`. |
 | `dispatch` | Mint an ephemeral, scoped api_key for a sub-agent dispatch, carrying its lineage path. The `raw_key` is returned ONCE — pass it to the sub-agent's launch args, never store it in env vars; it expires after `expires_in_seconds` (default 3600, max 14400). Required: `role` (`agent`/`orchestrator`), `agent_id`. Optional: `parent_dispatch_id`, `story_id`. |
 | `recover_cap` | Re-mint a capability token for a story you're assigned to, after a session crash lost your cap. Required: `story_id`. Optional: `cap_type` (`start_cap`/`report_cap`, default `start_cap`), `lineage`. |
 | `get_sth` | Get the latest Signed Tree Head for a tenant's tamper-evident audit chain. Public — no auth required. Required: `tenant_id`. |

package/index.js

@@ -189,6 +189,75 @@ async function apiCall(method, path, body, keyOverride, { exactKey = false } = {
   return responseBody;
 }
 
+/**
+ * Unauthenticated request helper for genuinely public endpoints (currently
+ * only POST /api/v1/signup). No Authorization header is sent — the public
+ * signup POST carries no witness header either (US-26.7.1), so this
+ * bypasses `witnessClientFor` entirely and calls `fetch` directly. Response
+ * parsing mirrors `apiCall`'s so callers can pass the result straight to
+ * `toContent`/`toContentCompact`.
+ */
+async function publicApiCall(method, path, body) {
+  const url = `${getBaseUrl()}${path}`;
+  const headers = { "Content-Type": "application/json", Accept: "application/json" };
+  const serializedBody =
+    body !== undefined && body !== null ? JSON.stringify(body) : undefined;
+
+  let response;
+  try {
+    response = await fetch(url, {
+      method,
+      headers,
+      body: serializedBody,
+      signal: AbortSignal.timeout(30_000),
+    });
+  } catch (err) {
+    if (err.name === "TimeoutError") {
+      return { error: true, status: 0, body: "Request timed out after 30s" };
+    }
+    const cause = err.cause?.message ? ` (${err.cause.message})` : "";
+    return { error: true, status: 0, body: `Network error: ${err.message}${cause}` };
+  }
+
+  if (response.status === 204) {
+    return { ok: true };
+  }
+
+  let responseBody;
+  const contentType = response.headers.get("content-type") || "";
+  if (contentType.includes("application/json")) {
+    const raw = await response.text();
+    const outcome = parseJsonResponseBody(raw, response.status);
+    if (outcome.error) {
+      return outcome;
+    }
+    responseBody = outcome.parsed;
+  } else {
+    const text = await response.text();
+    try {
+      responseBody = JSON.parse(text);
+    } catch {
+      responseBody = text;
+    }
+  }
+
+  if (!response.ok) {
+    let errorBody = responseBody;
+    if (typeof errorBody === "string" && errorBody.length > 500) {
+      errorBody = errorBody
+        .replace(/<[^>]+>/g, " ")
+        .replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">")
+        .replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/&nbsp;/g, " ")
+        .replace(/\s+/g, " ")
+        .trim()
+        .slice(0, 500) + "... (truncated)";
+    }
+    return { error: true, status: response.status, body: errorBody };
+  }
+
+  return responseBody;
+}
+
 function toContent(result) {
   const isErr = result && result.error === true;
   return {
@@ -233,6 +302,51 @@ function toContentCompact(result) {
   return toContent(result);
 }
 
+/**
+ * Surface a server-emitted BYO-LLM `remediation` PROMINENTLY as a leading text
+ * block. A stranger agent that calls knowledge_ingest / knowledge_search /
+ * knowledge_context BEFORE provisioning its keys then reads the exact next step
+ * in the tool result — call set_llm_config — instead of hunting through raw JSON.
+ *
+ * The remediation lives in one of two places depending on the failure shape:
+ *   - ingest no-key 422  → result.body.error.remediation (code "no_api_key")
+ *   - search/context degrade → result.meta.remediation (fallback_reason
+ *     "no_embedding_key"); the request still returns 200 keyword-only results.
+ *
+ * Returns a notice string, or null when there is no LLM remediation to surface.
+ */
+function llmRemediationNotice(result) {
+  const rem =
+    (result &&
+      result.error === true &&
+      result.body &&
+      result.body.error &&
+      result.body.error.remediation) ||
+    (result && result.meta && result.meta.remediation) ||
+    null;
+
+  if (!rem || rem.action !== "configure_llm") return null;
+
+  const missing = Array.isArray(rem.missing) ? rem.missing.join(", ") : rem.missing;
+  return (
+    `ACTION REQUIRED — BYO LLM key not configured (missing: ${missing}). ` +
+    `${rem.message || ""} Provision it ONCE with the ${rem.mcp_tool} MCP tool, e.g. ` +
+    `${rem.example} (REST: ${rem.api}). Requires your user-role key (LOOPCTL_USER_KEY). ` +
+    `Docs: ${rem.docs}`
+  ).replace(/\s+/g, " ").trim();
+}
+
+/**
+ * toContent, but with any BYO-LLM remediation notice prepended so it is the first
+ * thing the agent reads. Preserves isError from the underlying result.
+ */
+function withRemediationNotice(result) {
+  const base = toContent(result);
+  const notice = llmRemediationNotice(result);
+  if (!notice) return base;
+  return { ...base, content: [{ type: "text", text: notice }, ...base.content] };
+}
+
 // ---------------------------------------------------------------------------
 // Tool implementations
 // ---------------------------------------------------------------------------
@@ -831,7 +945,10 @@ async function knowledgeSearch({ q, project_id, story_id, category, tags, match,
   if (offset != null) params.set("offset", String(offset));
 
   const result = await apiCall("GET", `/api/v1/knowledge/search?${params}`, null, process.env.LOOPCTL_AGENT_KEY);
-  return toContent(result);
+  // If search silently degraded to keyword-only for a missing embedding key, the
+  // server attaches meta.remediation — surface it PROMINENTLY so the agent knows to
+  // call set_llm_config to enable semantic ranking.
+  return withRemediationNotice(result);
 }
 
 async function knowledgeList({
@@ -902,7 +1019,8 @@ async function knowledgeContext({
   if (conversation_id) params.set("conversation_id", conversation_id);
 
   const result = await apiCall("GET", `/api/v1/knowledge/context?${params}`, null, process.env.LOOPCTL_AGENT_KEY);
-  return toContent(result);
+  // Same as knowledge_search: surface a missing-embedding-key remediation prominently.
+  return withRemediationNotice(result);
 }
 
 async function knowledgeCreate({
@@ -1158,7 +1276,9 @@ async function knowledgeIngest({ url, content, source_type, project_id, publish
   if (project_id) body.project_id = project_id;
   if (publish) body.publish = true;
   const result = await apiCall("POST", "/api/v1/knowledge/ingest", body, process.env.LOOPCTL_ORCH_KEY);
-  return toContent(result);
+  // A keyless tenant gets a 422 (code no_api_key) carrying a remediation — surface it
+  // prominently so a first-time agent knows to call set_llm_config before ingesting.
+  return withRemediationNotice(result);
 }
 
 async function knowledgeIngestBatch({ items, project_id, publish }) {
@@ -1181,7 +1301,9 @@ async function knowledgeIngestBatch({ items, project_id, publish }) {
     { items: resolvedItems },
     process.env.LOOPCTL_ORCH_KEY
   );
-  return toContent(result);
+  // Batch ingest gates on the Anthropic key up front too — a keyless tenant gets a
+  // 422 with the same remediation; surface it prominently.
+  return withRemediationNotice(result);
 }
 
 async function knowledgeIngestionJobs(args = {}) {
@@ -1558,6 +1680,16 @@ async function createDispatch({
   return toContent(result);
 }
 
+// US-26.7.1: public, agent-rooted (KB-tier) self-signup. No API key required —
+// this creates the tenant AND the key. The resulting tenant is KB-tier only
+// (knowledge ingest/search/curate on the caller's own BYO LLM keys); the
+// work-breakdown / chain-of-custody surface requires a separate,
+// human-anchored WebAuthn signup ceremony at https://loopctl.com/signup.
+async function signup({ name, slug, email }) {
+  const result = await publicApiCall("POST", "/api/v1/signup", { name, slug, email });
+  return toContent(result);
+}
+
 // US-26: Signed Tree Head retrieval
 async function getSth({ tenant_id }) {
   const result = await apiCall("GET", `/api/v1/audit/sth/${tenant_id}`);
@@ -2618,7 +2750,9 @@ const TOOLS = [
       "If semantic ranking is unavailable the search transparently degrades to keyword-only " +
       "(meta.fallback: true, meta.search_mode: 'keyword_only') and now reports meta.fallback_reason " +
       "— a stable tag naming WHY (e.g. no_embedding_key, embedding_circuit_open, " +
-      "embedding_provider_error_<status>, embedding_timeout).",
+      "embedding_provider_error_<status>, embedding_timeout). When the reason is a MISSING " +
+      "embedding key (no_embedding_key), the result leads with an ACTION REQUIRED notice + " +
+      "meta.remediation telling you to provision it with set_llm_config (BYO — do it once).",
     inputSchema: {
       type: "object",
       properties: {
@@ -3296,7 +3430,10 @@ const TOOLS = [
       "Enqueues an Oban job that fetches the content (if URL), extracts knowledge articles via LLM, " +
       "and inserts them. Extracted articles are DRAFTS by default (lower-trust LLM output, staged " +
       "for review) — unlike knowledge_create which publishes by default. Pass publish:true to " +
-      "publish them on extraction. Requires orchestrator role.",
+      "publish them on extraction. Requires orchestrator role. BYO: extraction runs on the " +
+      "tenant's OWN Anthropic key — a keyless tenant gets a 422 (code no_api_key) and the " +
+      "result leads with an ACTION REQUIRED notice telling you to provision it once via " +
+      "set_llm_config.",
     inputSchema: {
       type: "object",
       properties: {
@@ -3409,29 +3546,44 @@ const TOOLS = [
   {
     name: "llm_config",
     description:
-      "Get the tenant's BYO Anthropic + embedding configuration: the per-operation " +
-      "model choices, whether each key is configured (has_api_key / has_embedding_key), " +
-      "and masked last-4 hints. NEVER returns a key itself. Requires user role " +
-      "(LOOPCTL_USER_KEY).",
+      "CHECK your BYO LLM onboarding status. Returns this tenant's per-operation model " +
+      "choices and whether each key is configured — `has_api_key` (Anthropic, powers " +
+      "ingest) and `has_embedding_key` (OpenAI embedding, powers semantic search) — plus " +
+      "masked last-4 hints. NEVER returns a key itself. Call this BEFORE ingest/search to " +
+      "confirm setup, or after set_llm_config to verify it took. Uses your user-role key " +
+      "(LOOPCTL_USER_KEY, obtained at signup); managing tenant secrets is user-only, so an " +
+      "agent/orchestrator key is rejected.",
     inputSchema: { type: "object", properties: {}, required: [] },
   },
   {
     name: "set_llm_config",
     description:
-      "Set/rotate the tenant's OWN Anthropic API key AND OpenAI embedding key (both " +
-      "stored encrypted, never returned) and the per-operation models " +
-      "(extraction/classification/merge/embedding). loopctl fronts no cost — the " +
-      "tenant's keys bill the tenant. Mandatory BYO for embeddings: without an " +
-      "embedding_api_key the tenant's articles are not vector-searchable. Any subset " +
-      "of fields may be sent; omitting a key leaves the existing key untouched. Model " +
-      "ids are free-form (any model the key permits). Requires user role " +
-      "(LOOPCTL_USER_KEY).",
+      "FIRST-TIME SETUP — do this ONCE, right after signup, to bring the wiki online. " +
+      "Provision your OWN Anthropic + OpenAI embedding keys so knowledge ingest AND " +
+      "semantic search work. loopctl is strictly BYO: it fronts NO LLM cost — your keys " +
+      "bill you directly and are stored ENCRYPTED, never returned. WHY it's required: with " +
+      "no `api_key`, knowledge_ingest returns 422 (code no_api_key); with no " +
+      "`embedding_api_key`, knowledge_search silently degrades to keyword-only " +
+      "(meta.fallback_reason: no_embedding_key) — both responses carry a `remediation` " +
+      "pointing back to THIS tool. WHICH key powers WHAT: `api_key` (Anthropic) → ingest " +
+      "extraction / classification / merge synthesis; `embedding_api_key` " +
+      "(OpenAI-compatible) → article embeddings + semantic ranking. All params are optional " +
+      "and partial-merge — omitting a key leaves the existing one untouched, so you can set " +
+      "or rotate one at a time. The per-operation model overrides " +
+      "(extraction_model / classification_model / merge_model / embedding_model) are " +
+      "free-form (any model the key permits) and default server-side when omitted. Typical " +
+      'onboarding call: set_llm_config({api_key: "sk-ant-...", embedding_api_key: "sk-..."}). ' +
+      "Verify anytime with llm_config (has_api_key / has_embedding_key). REQUIRES your " +
+      "user-role key LOOPCTL_USER_KEY (minted by the human-anchored signup ceremony); if it " +
+      "is unset the tool fails fast telling you to set it.",
     inputSchema: {
       type: "object",
       properties: {
         api_key: {
           type: "string",
-          description: "Anthropic API key (write-only; stored encrypted, never returned).",
+          description:
+            "Anthropic API key — powers knowledge ingest (extraction/classification/merge). " +
+            "Write-only; stored encrypted, never returned.",
         },
         extraction_model: {
           type: "string",
@@ -3448,7 +3600,9 @@ const TOOLS = [
         embedding_api_key: {
           type: "string",
           description:
-            "OpenAI-compatible embedding API key (write-only; stored encrypted, never returned).",
+            "OpenAI-compatible embedding API key — powers article embeddings + semantic " +
+            "search. Write-only; stored encrypted, never returned. Without it, articles are " +
+            "not vector-searchable and search degrades to keyword-only.",
         },
         embedding_model: {
           type: "string",
@@ -3713,6 +3867,31 @@ const TOOLS = [
   },
 
   // Chain of Custody v2 tools
+  {
+    name: "signup",
+    description:
+      "Create a NEW agent-rooted (KB-tier) tenant and mint its one-time root API key — " +
+      "entirely through this call, no human operator and no hardware authenticator required. " +
+      "Public — no existing API key needed to call this tool. The returned tenant can " +
+      "immediately use the FULL knowledge-wiki surface (ingest/search/context/curate, BYO " +
+      "LLM key config, agent registration) but CANNOT perform work-breakdown / " +
+      "chain-of-custody operations (create projects/epics/stories, claim/verify/report, " +
+      "dispatch, etc.) — those require a separate, human-anchored tenant created via the " +
+      "WebAuthn ceremony at https://loopctl.com/signup. Rate-limited per client IP " +
+      "(<= 5 signups/hour). The raw_key in the response is shown ONCE — save it immediately " +
+      "(e.g. as LOOPCTL_USER_KEY) since it cannot be retrieved again. Next steps after " +
+      "signup: configure your BYO LLM keys with set_llm_config, then register an agent " +
+      "identity, then ingest/search the wiki.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        name: { type: "string", description: "Tenant display name.", maxLength: 120 },
+        slug: { type: "string", description: "URL-safe unique tenant slug.", maxLength: 64 },
+        email: { type: "string", description: "Contact email for the tenant." },
+      },
+      required: ["name", "slug", "email"],
+    },
+  },
   {
     name: "get_sth",
     description: "Get the latest Signed Tree Head for a tenant's audit chain. Public — no auth required.",
@@ -4000,6 +4179,9 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
     case "dispatch":
       return await createDispatch(args);
 
+    case "signup":
+      return await signup(args);
+
     case "get_sth":
       return await getSth(args);
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "loopctl-mcp-server",
-  "version": "2.33.1",
+  "version": "2.35.0",
   "description": "MCP server for loopctl — structural trust for AI development loops",
   "type": "module",
   "main": "index.js",