loopctl-mcp-server 2.40.0 → 2.42.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 73 typed MCP tools so AI coding agents (Claude Code, etc.) can interact with loopctl without writing curl commands.
+Wraps the loopctl REST API into 76 typed MCP tools so AI coding agents (Claude Code, etc.) can interact with loopctl without writing curl commands.
 
 ## Installation
 
@@ -121,7 +121,7 @@ REST endpoint (`PATCH /api/v1/tenants/me/llm-config`), and the docs — so you (
 autonomous agent) can self-remediate without a human. Full agent-tenant lifecycle:
 [`docs/onboarding-agent-tenant.md`](../docs/onboarding-agent-tenant.md).
 
-## Tools (84)
+## Tools (89)
 
 > Plus **per-tenant generated Context Retriever tools** (`cr_*`) appended
 > dynamically at runtime — see [Dynamic per-tenant Context Retriever
@@ -133,6 +133,7 @@ autonomous agent) can self-remediate without a human. Full agent-tenant lifecycl
 |---|---|
 | `get_tenant` | Get current tenant info. Use to verify connectivity. |
 | `list_projects` | List all projects in the current tenant. |
+| `resolve_project` | Resolve a repo to its `project_id` in one cheap call — provide any of `slug`, `repo_url` (`git@github.com:owner/repo.git`, `https://github.com/owner/repo`, and bare `owner/repo` all match), or `name`. Precedence `slug > repo_url > name`, first match wins. Use the returned `id` to scope captures/recall (`memory_*`, `recall_context`). `404` `not_found` if nothing matches, `422` `no_identifier` if none supplied, `409` if a fuzzy identifier matches more than one active project. |
 | `create_project` | Create a new project in the current tenant. |
 | `delete_project` | **Requires `LOOPCTL_USER_KEY`.** Delete a project and all of its dependent resources (epics, stories, audit entries). Irreversible — orchestrator role is not sufficient. |
 | `get_progress` | Get progress summary for a project, including story counts by status. Pass `include_cost=true` for cost data. |
@@ -198,6 +199,8 @@ autonomous agent) can self-remediate without a human. Full agent-tenant lifecycl
 | How many articles? (counts only) | `knowledge_stats` |
 | Browse the catalog (lightweight id/title/category) | `knowledge_index` |
 | Find by topic / relevance (ranked, published-only, lags writes) | `knowledge_search` |
+| One trustworthy answer + provenance (curated-first, retrieval fallback) | `knowledge_hybrid_search` |
+| Survey a topic cheaply (capped stubs) then open only what you need | `knowledge_progressive_index` + `knowledge_progressive_drill` |
 | Enumerate / dedup / repair, or "does X exist?" (full fields, lag-free, all-status) | `knowledge_list` |
 
 | Tool | Description |
@@ -207,6 +210,9 @@ autonomous agent) can self-remediate without a human. Full agent-tenant lifecycl
 | `knowledge_count` | Count articles matching filters **without returning rows** within agent's visible set. Agent callers see only their own and `shared` articles. Same filters as `knowledge_list` (`category`, `status`, `tags`, `match`, `source_type`, `source_id`, `idempotency_key`, `project_id`). With `tags`+`match: all` (+`status`) → "how many published articles tagged both X and Y (that I can see)". Returns `{ count }`. |
 | `knowledge_facets` | Count articles grouped by **distinct tag** within agent's visible set, no rows. Agent callers see only their own and `shared` articles. `tag_prefix` (e.g. `book-`) gives the distinct count of a tag family plus per-member totals. Returns `{ data: { tag: count }, meta: { distinct_count } }`. Optional: `category`, `status`, `tags`, `match`, `project_id`, `limit`. |
 | `knowledge_search` | Search the knowledge wiki by topic (keyword, semantic, or combined). Returns snippets. **Ranked, published-only, and LAGS writes by minutes while embeddings index — do NOT use for existence/idempotency/dedup checks (a fresh write false-negatives); use `knowledge_list` for that.** `q` is optional when `tags`/`category` are supplied — that **list mode** returns the complete filtered set paginated via `offset`/`limit` over `meta.total_count`. `meta.total_count` is mode-dependent — read `meta.total_count_scope` (`keyword_matches`/`ranked_corpus`/`merged_candidates`/`filtered_set`) and don't use a relevance-mode count to size the wiki (use `knowledge_list` or `knowledge_stats`). Optional: `project_id`, `story_id` for attribution. |
+| `knowledge_hybrid_search` | Resolve a topic to a **single best answer with provenance** (US-31.4). Runs combined keyword+semantic over the full ranked pool, then decides whether a governed **curated** source actually answers. `meta.provenance` is `curated` (trust it — the canonical article is first in `data`, `meta.curated_article_id` points at it) or `retrieved` (best fuzzy match, `curated_article_id` null); `meta.confidence` is the winner's absolute score. Prefer over `knowledge_search` when you want one trustworthy answer, not a list to triage. Degrades to keyword-only like `knowledge_search` when embeddings are unavailable. Required: `query`. Optional: `project_id`, `category`, `tags`, `match`, `limit`, `offset`. |
+| `knowledge_progressive_index` | Progressive disclosure — a **cheap, capped index** of what's relevant to a topic (compact stubs: `id`/`title`/`category`/`summary`, **no bodies**), curated-preferred and hub-enriched, capped at top-K (`meta.truncated` when the pool exceeded it). Survey a topic without flooding context, then open only what you need via `knowledge_progressive_drill`. Required: `topic`. Optional: `category`, `limit`. |
+| `knowledge_progressive_drill` | Open one stub from `knowledge_progressive_index` — returns the **full article body** for the given id, scope-enforced. Resolves both tenant-owned articles and published system canonicals (the same set the index surfaces). Required: `article_id`. |
 | `knowledge_list` | List articles (`id`, `title`, `category`, `status`, `tags`, `source_type`, `source_id`, `idempotency_key`, timestamps), filtered + paginated. **Body-less summary by default** (safe to page up to `limit=1000`); pass `include_body: true` to also return `body`, in which case the page is bounded by a ~5 MB byte budget — continue via `meta.next_offset` while `meta.has_more`. **Lag-free, all-status** read of the DB of record — unlike `knowledge_search` (ranked, published-only, lags writes) and `knowledge_index` (id/title/category only). The right tool to enumerate/dedup/repair and for idempotency/existence checks: filter by `tags`, `source_type`+`source_id`, or `idempotency_key` and read `meta.total_count` (exact). Single full body → `knowledge_get`; relevant bodies → `knowledge_context`; bulk dump → `knowledge_export`. Optional: `project_id`, `category`, `status`, `tags`, `source_type`, `source_id`, `idempotency_key`, `offset`, `limit`, `include_body`. |
 | `knowledge_get` | Get full article content by ID. Use after search to read an article in detail. Optional: `project_id`, `story_id` for attribution. |
 | `knowledge_context` | Get relevance-and-recency-ranked full articles for a task query. Best knowledge for your current context. **Agent-memory scoping**: `memory_types` (comma-separated, OR — observation/finding/summary/decision/question/task), `agents` (comma-separated agent_ids, OR), `conversation_id` (exact) filter on article `metadata` (JSONB `@>`). Optional: `project_id`, `story_id` for attribution, `limit`, `recency_weight`. |
@@ -238,7 +244,9 @@ it is enforced server-side and a no-op for a non-superadmin key — see below.)
 | `memory_recall` | Semantically recall your own long-term memories most similar to `query`. When embedding generation is unavailable the response degrades to a recent-first text match with `meta.fallback: true` and a stable `meta.reason` (score is `null` on that path) — check `meta.fallback` before treating a short/empty result as a genuinely empty scope. `meta.total_count`/`meta.underfilled` are also returned. Optional: `limit`, `include_superseded`. |
 | `memory_list` | List your own long-term memories, newest first, paginated with `meta.total_count/limit/offset` (the true scoped count, never silently capped by `limit`). Optional: `limit`, `offset`, `include_superseded`, `all_subjects` (superadmin only; ignored for non-superadmin keys). |
 | `memory_forget` | Delete one of your own long-term memories by id. A foreign-subject, foreign-tenant, or unknown id returns 404 (no existence leak). Required: `id`. |
-| `memory_promote` | Call at session end to compile this session's short-term (`session`-tier) memory into durable `long_term` memory — unlike `memory_remember` (a single explicit write), this compiles the whole session in one shot; fire it once at session end, not per turn. Returns 202 with `{job_id, session_id, status: "enqueued"}` — promotion runs asynchronously, so the resulting memory is recallable via `memory_recall` only after the worker drains. You can only promote your own sessions (scope resolved server-side from your key). Required: `session_id`. |
+| `memory_promote` | Call at session end to compile this session's short-term (`session`-tier) memory into durable `long_term` memory — unlike `memory_remember` (a single explicit write), this compiles the whole session in one shot; fire it once at session end, not per turn. Returns 202 with `{session_id, status: "enqueued"}` — promotion runs asynchronously, so the resulting memory is recallable via `memory_recall` only after the worker drains. You can only promote your own sessions (scope resolved server-side from your key). Required: `session_id`. |
+| `recall_context` | ONE round-trip returning the re-ranked `global ∪ active-project` union of long-term MEMORY **and** KNOWLEDGE for `query` — what you previously assembled by calling `memory_recall` and `knowledge_search` separately. Pass `project_id` (from `resolve_project`) to merge global with that project on both sides; absent → global-only. The knowledge half is combined-search *summaries* (not full bodies — use `knowledge_context` for those). Response carries merged `results` (each tagged `source: memory\|knowledge`) plus the untouched per-source `memory`/`knowledge` envelopes; `meta.degraded?` flags a one-sided degrade (the other side is still returned — never a 500). A blank query, or one over 500 chars, is a `422` up front. Required: `query`. Optional: `project_id`, `limit`. |
+| `memory_graduate` | Graduate ONE of your long-term memories into a durable Knowledge Wiki article — the explicit, on-demand version of the hourly graduation sweep. Use when a private memory has proven valuable enough to become durable knowledge. **Visibility**: the graduated article stays **owner-visible** (`metadata.visibility: "owner"`, keyed to your subject) — discoverable by YOU, NOT peer-readable (graduation does not share a memory to teammates; `re_scope: "global"` widens only the project scope, not visibility). Scope is key-derived (you can only graduate your OWN memory; a foreign/unknown `memory_id` → 404). DEDUPED by the novelty gate: `data.verdict` is `created` (novel → published) or `gated_to_draft` (near-dup → review draft) with a new article (**201**), or `duplicate`/`deduplicated` (already represented → canonical article, nothing created) (**200**). By default the article inherits the memory's project scope; pass `re_scope: "global"` to promote a PROJECT memory to a tenant-wide article — only valid on its FIRST graduation, and only if the hourly sweep hasn't graduated it project-scoped first (`409` `already_graduated` otherwise). An already-graduated global memory re-graduates idempotently (**200**). `503` `gate_unavailable` if the embedding backend is down — retry later. Required: `memory_id`. Optional: `re_scope` (`inherit`\|`global`). |
 
 ### Knowledge Management Tools (orchestrator key)
 

package/index.js

@@ -376,6 +376,22 @@ async function listProjects(args = {}) {
   return toContent(result);
 }
 
+async function resolveProject({ slug, repo_url, name } = {}) {
+  // Cheap repo -> project_id resolution (loopctl #411 Gap 1). Server tries
+  // slug -> repo_url -> name and returns the first match; agent-role read.
+  const params = new URLSearchParams();
+  if (slug) params.set("slug", slug);
+  if (repo_url) params.set("repo_url", repo_url);
+  if (name) params.set("name", name);
+  const result = await apiCall(
+    "GET",
+    `/api/v1/projects/resolve?${params}`,
+    null,
+    process.env.LOOPCTL_AGENT_KEY,
+  );
+  return toContent(result);
+}
+
 async function createProject({ name, slug, repo_url, description, tech_stack, mission }) {
   const body = { name, slug };
   if (repo_url) body.repo_url = repo_url;
@@ -962,6 +978,52 @@ async function knowledgeSearch({ q, project_id, story_id, category, tags, match,
   return withRemediationNotice(result);
 }
 
+async function knowledgeHybridSearch({ query, project_id, category, tags, match, limit, offset }) {
+  const bodyPayload = { query };
+  if (project_id) bodyPayload.project_id = project_id;
+  if (category) bodyPayload.category = category;
+  if (tags) bodyPayload.tags = tags;
+  if (match) bodyPayload.match = match;
+  if (limit != null) bodyPayload.limit = limit;
+  if (offset != null) bodyPayload.offset = offset;
+
+  const result = await apiCall(
+    "POST",
+    "/api/v1/knowledge/hybrid_search",
+    bodyPayload,
+    process.env.LOOPCTL_AGENT_KEY,
+  );
+  // meta.provenance ("curated" | "retrieved") is the load-bearing field and rides
+  // through toContent verbatim. Same missing-embedding-key remediation surfacing as
+  // knowledge_search, since hybrid runs the combined pool underneath.
+  return withRemediationNotice(result);
+}
+
+async function knowledgeProgressiveIndex({ topic, category, limit }) {
+  const params = new URLSearchParams();
+  if (topic != null) params.set("topic", topic);
+  if (category) params.set("category", category);
+  if (limit != null) params.set("limit", String(limit));
+
+  const result = await apiCall(
+    "GET",
+    `/api/v1/knowledge/progressive_index?${params}`,
+    null,
+    process.env.LOOPCTL_AGENT_KEY,
+  );
+  return toContent(result);
+}
+
+async function knowledgeProgressiveDrill({ article_id }) {
+  const result = await apiCall(
+    "GET",
+    `/api/v1/knowledge/progressive/${article_id}`,
+    null,
+    process.env.LOOPCTL_AGENT_KEY,
+  );
+  return toContent(result);
+}
+
 async function knowledgeList({
   project_id,
   category,
@@ -1160,6 +1222,26 @@ async function memoryRecall({ query, limit, include_superseded }) {
   return toContent(result);
 }
 
+async function recallContext({ query, project_id, limit }) {
+  // Merged recall (#411 Gap 2): ONE round-trip returning the re-ranked
+  // global ∪ active-project union of long-term MEMORY and KNOWLEDGE. Scope
+  // (tenant_id/subject_id) is derived server-side from the agent key; project_id is
+  // the partition key (merges global with that project on BOTH sides).
+  const payload = { query };
+  if (project_id) payload.project_id = project_id;
+  if (limit != null) payload.limit = limit;
+
+  const result = await apiCall(
+    "POST",
+    "/api/v1/recall",
+    payload,
+    process.env.LOOPCTL_AGENT_KEY,
+  );
+  // Surface both per-source metas (memory fallback/underfilled + knowledge degraded)
+  // so the caller can tell a degraded recall from a genuinely empty scope.
+  return toContent(result);
+}
+
 async function memoryList({ limit, offset, include_superseded, all_subjects }) {
   // all_subjects is superadmin-only server-side; a non-superadmin key sending
   // this is ignored (falls back to its own subject) rather than erroring — the
@@ -1200,6 +1282,24 @@ async function memoryPromote({ session_id }) {
   return toContent(result);
 }
 
+async function memoryGraduate({ memory_id, re_scope }) {
+  // Explicit memory→knowledge graduation (#411 Gap 3). Scope (tenant_id/subject_id)
+  // is derived server-side from the agent key; memory_id identifies the caller's OWN
+  // memory to graduate. The graduated article stays OWNER-visible (not peer-readable).
+  // re_scope: "global" widens only the project partition (project → tenant-wide), NOT
+  // visibility, and only on the memory's first graduation.
+  const payload = { memory_id };
+  if (re_scope) payload.re_scope = re_scope;
+
+  const result = await apiCall(
+    "POST",
+    "/api/v1/memory/graduate",
+    payload,
+    process.env.LOOPCTL_AGENT_KEY,
+  );
+  return toContent(result);
+}
+
 // --- Knowledge Management Tools (orch key) ---
 
 async function knowledgePublish({ article_id }) {
@@ -1952,6 +2052,34 @@ const TOOLS = [
       required: [],
     },
   },
+  {
+    name: "resolve_project",
+    description:
+      "Resolve a repo to its project in one cheap call. Provide any of slug, " +
+      "repo_url (git@github.com:owner/repo.git, https://github.com/owner/repo, " +
+      "and bare owner/repo all match), or name. Precedence: slug > repo_url > " +
+      "name; first match wins. Returns the project (use its id to scope " +
+      "captures/recall), 404 not_found if nothing matches, 422 no_identifier " +
+      "if none supplied.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        slug: {
+          type: "string",
+          description: "Exact project slug (often the repo basename).",
+        },
+        repo_url: {
+          type: "string",
+          description: "Git remote URL or bare owner/repo.",
+        },
+        name: {
+          type: "string",
+          description: "Exact project name (case-insensitive).",
+        },
+      },
+      required: [],
+    },
+  },
   {
     name: "create_project",
     description: "Create a new project in the current tenant.",
@@ -3005,6 +3133,109 @@ const TOOLS = [
       required: [],
     },
   },
+  {
+    name: "knowledge_hybrid_search",
+    description:
+      "Resolve a topic to a SINGLE best answer WITH provenance — the hybrid " +
+      "retrieval entrypoint. Runs the combined keyword+semantic search over the full " +
+      "ranked pool, then decides whether a governed CURATED source actually answers. " +
+      "The verdict is meta.provenance: 'curated' means a curated, canonical article " +
+      "answers — TRUST IT (it is guaranteed first in the results and meta.curated_article_id " +
+      "points at it); 'retrieved' means no curated source cleared the bar, so the answer " +
+      "is the best semantic/keyword match (a fuzzy fallback — verify before relying on it, " +
+      "meta.curated_article_id is null). meta.confidence is the winning candidate's absolute " +
+      "score for its provenance class. Prefer this over knowledge_search when you want ONE " +
+      "trustworthy answer plus its provenance rather than a ranked list to triage yourself; " +
+      "use knowledge_search when you want to browse/enumerate matches. Additive — existing " +
+      "knowledge tools are unchanged. If semantic ranking is unavailable it degrades to " +
+      "keyword-only (meta.fallback/fallback_reason), same as knowledge_search.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        query: {
+          type: "string",
+          description: "The topic/question to resolve (max 500 characters). Required.",
+        },
+        project_id: {
+          type: "string",
+          format: "uuid",
+          description: "Optional: scope to a project UUID.",
+        },
+        category: {
+          type: "string",
+          description: "Optional: filter by category.",
+        },
+        tags: {
+          type: "string",
+          description: "Optional: comma-separated tags to filter by.",
+        },
+        match: {
+          type: "string",
+          enum: ["any", "all"],
+          description: "Optional: tag match mode — 'any' (default, OR) or 'all' (AND, every tag).",
+        },
+        limit: {
+          type: "integer",
+          description: "Optional: max results to return (default 10).",
+        },
+        offset: {
+          type: "integer",
+          description: "Optional: results to skip for pagination (default 0).",
+        },
+      },
+      required: ["query"],
+    },
+  },
+  {
+    name: "knowledge_progressive_index",
+    description:
+      "Progressive disclosure — get a CHEAP, capped index of what's relevant to a topic " +
+      "(compact stubs: id/title/category/summary, NO bodies), then open only what you need " +
+      "with knowledge_progressive_drill. Curated sources are preferred and hub-linked " +
+      "neighbors are enriched in; results are capped at a configured top-K (meta.truncated " +
+      "is true when the candidate pool exceeded it). Use this to survey a topic without " +
+      "flooding your context with full article bodies — it's the index half of the hybrid " +
+      "interface. Follow up on a stub's id with knowledge_progressive_drill to read the body.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        topic: {
+          type: "string",
+          description: "The topic to index (max 500 characters). Required.",
+        },
+        category: {
+          type: "string",
+          description: "Optional: filter by category.",
+        },
+        limit: {
+          type: "integer",
+          description: "Optional: top-K override (clamped to the configured cap).",
+        },
+      },
+      required: ["topic"],
+    },
+  },
+  {
+    name: "knowledge_progressive_drill",
+    description:
+      "Drill into one stub from knowledge_progressive_index — returns the FULL article " +
+      "body for the given id, scope-enforced. Resolves both tenant-owned articles and " +
+      "published system canonicals (the same set the index surfaces). This is the drill " +
+      "half of progressive disclosure: index cheaply, then open only the article(s) you " +
+      "need. (knowledge_get works for tenant articles too; use this to also reach the " +
+      "system canonicals the progressive index can surface.)",
+    inputSchema: {
+      type: "object",
+      properties: {
+        article_id: {
+          type: "string",
+          format: "uuid",
+          description: "The UUID of the article to open (from a progressive index stub).",
+        },
+      },
+      required: ["article_id"],
+    },
+  },
   {
     name: "knowledge_get",
     description:
@@ -3335,6 +3566,45 @@ const TOOLS = [
       required: ["query"],
     },
   },
+  {
+    name: "recall_context",
+    description:
+      "MERGED recall in ONE round-trip: the re-ranked global ∪ active-project union of " +
+      "your long-term MEMORY (private working state) AND the shared KNOWLEDGE wiki for " +
+      "`query` — instead of calling memory_recall and knowledge_context/knowledge_search " +
+      "separately and merging by hand (#411 Gap 2). Both sides merge global with the " +
+      "active project: pass project_id to include that project's rows alongside global " +
+      "ones on BOTH sides (another project's rows are excluded); omit it for global-only. " +
+      "project_id is a PARTITION key, NOT isolation — scope (tenant/subject) is resolved " +
+      "server-side from your key. Returns `data` (merged, each item tagged source: " +
+      "memory|knowledge, sorted by a heuristically-comparable score DESC) PLUS the " +
+      "untouched per-source `memory` and `knowledge` envelopes so you can re-rank. " +
+      "Cross-source scores are heuristic, not calibrated. If the knowledge search " +
+      "degrades (embedding unavailable) or errors, the memory side is still returned and " +
+      "meta.degraded is true — never a hard failure.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        query: {
+          type: "string",
+          description: "Text to embed / match against on BOTH the memory and knowledge sides.",
+        },
+        project_id: {
+          type: "string",
+          format: "uuid",
+          description:
+            "Optional: partition scope. Present → both sides return global ∪ that project; " +
+            "omit → global-only.",
+        },
+        limit: {
+          type: "integer",
+          description:
+            "Optional: overall merged page size, clamped to [1, 50] (default 10).",
+        },
+      },
+      required: ["query"],
+    },
+  },
   {
     name: "memory_list",
     description:
@@ -3413,6 +3683,45 @@ const TOOLS = [
       required: ["session_id"],
     },
   },
+  {
+    name: "memory_graduate",
+    description:
+      "Graduate ONE of your long-term memories into a durable Knowledge Wiki article — the " +
+      "explicit, on-demand version of the hourly graduation sweep. Use when a private memory " +
+      "has proven valuable enough to become durable, curated knowledge. IMPORTANT: the " +
+      "graduated article stays OWNER-VISIBLE (metadata.visibility=owner, keyed to your " +
+      "subject) — discoverable by YOU, NOT peer-readable; graduation does NOT share a memory " +
+      "with teammates, and re_scope only widens project scope, not visibility. Scope " +
+      "(tenant_id/subject_id) is resolved server-side from your API key: you can only " +
+      "graduate your OWN memory; a foreign/unknown memory_id returns 404 (no cross-subject " +
+      "leak). By default the article inherits the memory's project scope; pass " +
+      're_scope: "global" to promote a PROJECT memory to a tenant-wide (global) article — ' +
+      "only valid on the memory's FIRST graduation (re_scope: global on an already-graduated " +
+      "PROJECT memory returns 409 already_graduated; on an already-graduated GLOBAL memory it " +
+      "is an idempotent no-op → 200). The article is DEDUPED by the novelty gate: the " +
+      'response `data.verdict` is "created" (novel → published) or "gated_to_draft" ' +
+      '(near-duplicate → review draft) with a new article, or "duplicate"/"deduplicated" ' +
+      "(content already represented → the canonical article, nothing created). Returns 503 " +
+      "gate_unavailable if the embedding backend is down — retry later.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        memory_id: {
+          type: "string",
+          description: "UUID of your own long-term memory to graduate into a knowledge article.",
+        },
+        re_scope: {
+          type: "string",
+          enum: ["inherit", "global"],
+          description:
+            'Article scope. "inherit" (default) keeps the memory\'s project scope; ' +
+            '"global" promotes a PROJECT memory to a tenant-wide (global) article ' +
+            "(only on its first graduation).",
+        },
+      },
+      required: ["memory_id"],
+    },
+  },
 
   // Knowledge Management Tools (orchestrator key)
   {
@@ -4545,6 +4854,9 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
     case "list_projects":
       return await listProjects(args);
 
+    case "resolve_project":
+      return await resolveProject(args);
+
     case "create_project":
       return await createProject(args);
 
@@ -4654,6 +4966,15 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
     case "knowledge_search":
       return await knowledgeSearch(args);
 
+    case "knowledge_hybrid_search":
+      return await knowledgeHybridSearch(args);
+
+    case "knowledge_progressive_index":
+      return await knowledgeProgressiveIndex(args);
+
+    case "knowledge_progressive_drill":
+      return await knowledgeProgressiveDrill(args);
+
     case "knowledge_list":
       return await knowledgeList(args);
 
@@ -4675,6 +4996,8 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
 
     case "memory_recall":
       return await memoryRecall(args);
+    case "recall_context":
+      return await recallContext(args);
 
     case "memory_list":
       return await memoryList(args);
@@ -4685,6 +5008,9 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
     case "memory_promote":
       return await memoryPromote(args);
 
+    case "memory_graduate":
+      return await memoryGraduate(args);
+
     // Knowledge Management Tools
     case "knowledge_publish":
       return await knowledgePublish(args);

package/package.json

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