@memnexus-ai/typescript-sdk 1.53.29 → 1.55.0-next.0

package/dist/index.js

@@ -37,6 +37,9 @@ var SdkError = class _SdkError extends Error {
     this.name = "SdkError";
     Object.setPrototypeOf(this, _SdkError.prototype);
   }
+  status;
+  statusText;
+  data;
 };
 
 // src/http/handlers.ts
@@ -1318,6 +1321,31 @@ var PatternsService = class extends BaseService {
     }
     return this.client.call(request);
   }
+  /**
+     * Compile behavioral instructions from stored patterns
+     * Converts stored behavioral patterns into actionable instructions suitable for injection into AI agent context at conversation start. Uses template-based (non-LLM) generation for deterministic output within the P95 <100ms budget.
+  
+     * @param body - Request body
+     */
+  async compileInstructions(options) {
+    const request = new Request({
+      baseUrl: this.config.baseUrl || "http://localhost:3000",
+      method: "POST",
+      path: "/api/patterns/compile-instructions",
+      config: this.config,
+      retry: {
+        attempts: 3,
+        delayMs: 150,
+        maxDelayMs: 5e3,
+        jitterMs: 50,
+        backoffFactor: 2
+      }
+    });
+    if (options?.body !== void 0) {
+      request.addBody(options?.body);
+    }
+    return this.client.call(request);
+  }
 };
 
 // src/services/behavior-service.ts
@@ -1368,6 +1396,262 @@ var BehaviorService = class extends BaseService {
   }
 };
 
+// src/services/recommendations-service.ts
+var RecommendationsService = class extends BaseService {
+  /**
+     * Create an explicit recommendation
+     * Create a new explicit recommendation (triggerContext + practice pair). Source is set to 'explicit'; triggerEmbedding is generated synchronously before return. SEC-BL-v2-002: practice content is validated against a prompt-injection deny-list. SEC-BL-v2-003: evidenceMemoryIds ownership is verified against the authenticated user.
+  
+     * @param body - Request body
+     */
+  async createRecommendation(body) {
+    const request = new Request({
+      baseUrl: this.config.baseUrl || "http://localhost:3000",
+      method: "POST",
+      path: "/api/patterns/recommendations",
+      config: this.config,
+      retry: {
+        attempts: 3,
+        delayMs: 150,
+        maxDelayMs: 5e3,
+        jitterMs: 50,
+        backoffFactor: 2
+      }
+    });
+    if (body !== void 0) {
+      request.addBody(body);
+    }
+    return this.client.call(request);
+  }
+  /**
+     * List pending recommendations
+     * Returns recommendations with status='pending_review' for the authenticated user, ordered by confidence DESC, createdAt ASC.
+  
+     * @param limit - Maximum number of results
+     * @param offset - Number of results to skip
+     */
+  async listPendingRecommendations(options) {
+    const request = new Request({
+      baseUrl: this.config.baseUrl || "http://localhost:3000",
+      method: "GET",
+      path: "/api/patterns/recommendations/pending",
+      config: this.config,
+      retry: {
+        attempts: 3,
+        delayMs: 150,
+        maxDelayMs: 5e3,
+        jitterMs: 50,
+        backoffFactor: 2
+      }
+    });
+    if (options?.limit !== void 0) {
+      request.addQueryParam("limit", {
+        key: "limit",
+        value: options.limit,
+        explode: false,
+        encode: true,
+        style: "form",
+        isLimit: true,
+        isOffset: false,
+        isCursor: false
+      });
+    }
+    if (options?.offset !== void 0) {
+      request.addQueryParam("offset", {
+        key: "offset",
+        value: options.offset,
+        explode: false,
+        encode: true,
+        style: "form",
+        isLimit: false,
+        isOffset: true,
+        isCursor: false
+      });
+    }
+    return this.client.call(request);
+  }
+  /**
+     * Approve a pending recommendation
+     * Transitions a recommendation from status='pending_review' to status='active'. Returns 404 if the recommendation is not found, not owned by the authenticated user, or is not in pending_review status.
+  
+     * @param id - Recommendation ID
+     * @param body - Request body
+     */
+  async approveRecommendation(id, options) {
+    const request = new Request({
+      baseUrl: this.config.baseUrl || "http://localhost:3000",
+      method: "PATCH",
+      path: "/api/patterns/recommendations/{id}/approve",
+      config: this.config,
+      retry: {
+        attempts: 3,
+        delayMs: 150,
+        maxDelayMs: 5e3,
+        jitterMs: 50,
+        backoffFactor: 2
+      }
+    });
+    request.addPathParam("id", {
+      key: "id",
+      value: id,
+      explode: false,
+      encode: true,
+      style: "simple",
+      isLimit: false,
+      isOffset: false,
+      isCursor: false
+    });
+    if (options?.body !== void 0) {
+      request.addBody(options?.body);
+    }
+    return this.client.call(request);
+  }
+  /**
+     * Dismiss a recommendation
+     * Permanently dismisses a recommendation (any non-dismissed status → dismissed). This transition is terminal — dismissed recommendations cannot be reactivated. Returns 404 if not found, not owned by the authenticated user, or already dismissed.
+  
+     * @param id - Recommendation ID
+     * @param body - Request body
+     */
+  async dismissRecommendation(id, options) {
+    const request = new Request({
+      baseUrl: this.config.baseUrl || "http://localhost:3000",
+      method: "PATCH",
+      path: "/api/patterns/recommendations/{id}/dismiss",
+      config: this.config,
+      retry: {
+        attempts: 3,
+        delayMs: 150,
+        maxDelayMs: 5e3,
+        jitterMs: 50,
+        backoffFactor: 2
+      }
+    });
+    request.addPathParam("id", {
+      key: "id",
+      value: id,
+      explode: false,
+      encode: true,
+      style: "simple",
+      isLimit: false,
+      isOffset: false,
+      isCursor: false
+    });
+    if (options?.body !== void 0) {
+      request.addBody(options?.body);
+    }
+    return this.client.call(request);
+  }
+  /**
+     * List active recommendations
+     * Returns recommendations with status='active' for the authenticated user, ordered by confidence DESC. These are the behavioral preferences currently surfacing in Claude via compile-instructions and build_context. SEC-BL-v2-003: results are scoped to the authenticated user — no cross-user data.
+  
+     * @param limit - Maximum number of results
+     * @param offset - Number of results to skip
+     */
+  async listActiveRecommendations(options) {
+    const request = new Request({
+      baseUrl: this.config.baseUrl || "http://localhost:3000",
+      method: "GET",
+      path: "/api/patterns/recommendations/active",
+      config: this.config,
+      retry: {
+        attempts: 3,
+        delayMs: 150,
+        maxDelayMs: 5e3,
+        jitterMs: 50,
+        backoffFactor: 2
+      }
+    });
+    if (options?.limit !== void 0) {
+      request.addQueryParam("limit", {
+        key: "limit",
+        value: options.limit,
+        explode: false,
+        encode: true,
+        style: "form",
+        isLimit: true,
+        isOffset: false,
+        isCursor: false
+      });
+    }
+    if (options?.offset !== void 0) {
+      request.addQueryParam("offset", {
+        key: "offset",
+        value: options.offset,
+        explode: false,
+        encode: true,
+        style: "form",
+        isLimit: false,
+        isOffset: true,
+        isCursor: false
+      });
+    }
+    return this.client.call(request);
+  }
+  /**
+     * Match active recommendations to content
+     * Embeds the supplied content and returns active Recommendations whose triggerContext is semantically similar. Used by the MCP server for just-in-time behavioral nudges on memory save. Results are scoped to the authenticated user — no cross-user data is returned.
+  
+     * @param body - Request body
+     */
+  async matchRecommendations(body) {
+    const request = new Request({
+      baseUrl: this.config.baseUrl || "http://localhost:3000",
+      method: "POST",
+      path: "/api/patterns/recommendations/match",
+      config: this.config,
+      retry: {
+        attempts: 3,
+        delayMs: 150,
+        maxDelayMs: 5e3,
+        jitterMs: 50,
+        backoffFactor: 2
+      }
+    });
+    if (body !== void 0) {
+      request.addBody(body);
+    }
+    return this.client.call(request);
+  }
+  /**
+     * Pause an active recommendation
+     * Transitions a recommendation from status='active' to status='paused'. Paused recommendations are excluded from compile-instructions and build_context surfacing. Returns 404 if the recommendation is not found, not owned by the authenticated user, or is not in active status. SEC-BL-v2-003: MATCH includes userId — no IDOR.
+  
+     * @param id - Recommendation ID
+     * @param body - Request body
+     */
+  async pauseRecommendation(id, options) {
+    const request = new Request({
+      baseUrl: this.config.baseUrl || "http://localhost:3000",
+      method: "PATCH",
+      path: "/api/patterns/recommendations/{id}/pause",
+      config: this.config,
+      retry: {
+        attempts: 3,
+        delayMs: 150,
+        maxDelayMs: 5e3,
+        jitterMs: 50,
+        backoffFactor: 2
+      }
+    });
+    request.addPathParam("id", {
+      key: "id",
+      value: id,
+      explode: false,
+      encode: true,
+      style: "simple",
+      isLimit: false,
+      isOffset: false,
+      isCursor: false
+    });
+    if (options?.body !== void 0) {
+      request.addBody(options?.body);
+    }
+    return this.client.call(request);
+  }
+};
+
 // src/services/narratives-service.ts
 var NarrativesService = class extends BaseService {
   /**
@@ -1858,6 +2142,106 @@ var MemoriesService = class extends BaseService {
     });
     return this.client.call(request);
   }
+  /**
+     * Aggregated memory analytics
+     * Return aggregated memory counts grouped by a time dimension (day, week, month)
+  or by topic. Useful for activity dashboards and trend analysis.
+  
+     * @param groupBy - Dimension to group counts by: day (YYYY-MM-DD), week (YYYY-Www), month (YYYY-MM), or topic
+     * @param after - Filter memories on or after this ISO 8601 timestamp
+     * @param before - Filter memories on or before this ISO 8601 timestamp
+     * @param recent - Shorthand time window relative to now (e.g. 7d, 2w, 1mo). Sets the lower bound. Takes precedence over `after`.
+     * @param topic - Pre-filter to memories that contain this topic before grouping
+     * @param limit - Maximum number of buckets to return
+     */
+  async getMemoriesStats(options) {
+    const request = new Request({
+      baseUrl: this.config.baseUrl || "http://localhost:3000",
+      method: "GET",
+      path: "/api/memories/stats",
+      config: this.config,
+      retry: {
+        attempts: 3,
+        delayMs: 150,
+        maxDelayMs: 5e3,
+        jitterMs: 50,
+        backoffFactor: 2
+      }
+    });
+    if (options?.groupBy !== void 0) {
+      request.addQueryParam("groupBy", {
+        key: "groupBy",
+        value: options.groupBy,
+        explode: false,
+        encode: true,
+        style: "form",
+        isLimit: false,
+        isOffset: false,
+        isCursor: false
+      });
+    }
+    if (options?.after !== void 0) {
+      request.addQueryParam("after", {
+        key: "after",
+        value: options.after,
+        explode: false,
+        encode: true,
+        style: "form",
+        isLimit: false,
+        isOffset: false,
+        isCursor: false
+      });
+    }
+    if (options?.before !== void 0) {
+      request.addQueryParam("before", {
+        key: "before",
+        value: options.before,
+        explode: false,
+        encode: true,
+        style: "form",
+        isLimit: false,
+        isOffset: false,
+        isCursor: false
+      });
+    }
+    if (options?.recent !== void 0) {
+      request.addQueryParam("recent", {
+        key: "recent",
+        value: options.recent,
+        explode: false,
+        encode: true,
+        style: "form",
+        isLimit: false,
+        isOffset: false,
+        isCursor: false
+      });
+    }
+    if (options?.topic !== void 0) {
+      request.addQueryParam("topic", {
+        key: "topic",
+        value: options.topic,
+        explode: false,
+        encode: true,
+        style: "form",
+        isLimit: false,
+        isOffset: false,
+        isCursor: false
+      });
+    }
+    if (options?.limit !== void 0) {
+      request.addQueryParam("limit", {
+        key: "limit",
+        value: options.limit,
+        explode: false,
+        encode: true,
+        style: "form",
+        isLimit: true,
+        isOffset: false,
+        isCursor: false
+      });
+    }
+    return this.client.call(request);
+  }
   /**
      * List memories
      * List all memories for the authenticated user with pagination.
@@ -1875,6 +2259,13 @@ var MemoriesService = class extends BaseService {
      * @param page - Page number (alternative to offset)
      * @param sortBy - Field to sort results by
      * @param order - Sort order
+     * @param from - Filter memories created on or after this ISO 8601 timestamp (ingestion time lower bound)
+     * @param to - Filter memories created on or before this ISO 8601 timestamp (ingestion time upper bound)
+     * @param recent - Shorthand time filter relative to now (e.g. "24h", "7d", "2w"). Sets the lower bound for ingestion time. Takes precedence over `from` when both are provided.
+     * @param topics - Comma-separated topic names. Memories must have at least one matching topic.
+     * @param excludeTopics - Comma-separated topic names. Memories with any matching topic are excluded.
+     * @param conversationId - Filter to memories belonging to the given conversation.
+     * @param scope - Filter by codeContext scope. Comma-separated key:value pairs (e.g. scope=product:memnexus,team:retrieval). Memories must match ALL specified scope pairs. Allowed keys, product, service, team, role — unknown keys return 400.
      */
   async listMemories(options) {
     const request = new Request({
@@ -1922,14 +2313,98 @@ var MemoriesService = class extends BaseService {
         encode: true,
         style: "form",
         isLimit: false,
-        isOffset: true,
+        isOffset: true,
+        isCursor: false
+      });
+    }
+    if (options?.page !== void 0) {
+      request.addQueryParam("page", {
+        key: "page",
+        value: options.page,
+        explode: false,
+        encode: true,
+        style: "form",
+        isLimit: false,
+        isOffset: false,
+        isCursor: false
+      });
+    }
+    if (options?.sortBy !== void 0) {
+      request.addQueryParam("sortBy", {
+        key: "sortBy",
+        value: options.sortBy,
+        explode: false,
+        encode: true,
+        style: "form",
+        isLimit: false,
+        isOffset: false,
+        isCursor: false
+      });
+    }
+    if (options?.order !== void 0) {
+      request.addQueryParam("order", {
+        key: "order",
+        value: options.order,
+        explode: false,
+        encode: true,
+        style: "form",
+        isLimit: false,
+        isOffset: false,
+        isCursor: false
+      });
+    }
+    if (options?.from !== void 0) {
+      request.addQueryParam("from", {
+        key: "from",
+        value: options.from,
+        explode: false,
+        encode: true,
+        style: "form",
+        isLimit: false,
+        isOffset: false,
+        isCursor: false
+      });
+    }
+    if (options?.to !== void 0) {
+      request.addQueryParam("to", {
+        key: "to",
+        value: options.to,
+        explode: false,
+        encode: true,
+        style: "form",
+        isLimit: false,
+        isOffset: false,
+        isCursor: false
+      });
+    }
+    if (options?.recent !== void 0) {
+      request.addQueryParam("recent", {
+        key: "recent",
+        value: options.recent,
+        explode: false,
+        encode: true,
+        style: "form",
+        isLimit: false,
+        isOffset: false,
+        isCursor: false
+      });
+    }
+    if (options?.topics !== void 0) {
+      request.addQueryParam("topics", {
+        key: "topics",
+        value: options.topics,
+        explode: false,
+        encode: true,
+        style: "form",
+        isLimit: false,
+        isOffset: false,
         isCursor: false
       });
     }
-    if (options?.page !== void 0) {
-      request.addQueryParam("page", {
-        key: "page",
-        value: options.page,
+    if (options?.excludeTopics !== void 0) {
+      request.addQueryParam("excludeTopics", {
+        key: "excludeTopics",
+        value: options.excludeTopics,
         explode: false,
         encode: true,
         style: "form",
@@ -1938,10 +2413,10 @@ var MemoriesService = class extends BaseService {
         isCursor: false
       });
     }
-    if (options?.sortBy !== void 0) {
-      request.addQueryParam("sortBy", {
-        key: "sortBy",
-        value: options.sortBy,
+    if (options?.conversationId !== void 0) {
+      request.addQueryParam("conversationId", {
+        key: "conversationId",
+        value: options.conversationId,
         explode: false,
         encode: true,
         style: "form",
@@ -1950,10 +2425,10 @@ var MemoriesService = class extends BaseService {
         isCursor: false
       });
     }
-    if (options?.order !== void 0) {
-      request.addQueryParam("order", {
-        key: "order",
-        value: options.order,
+    if (options?.scope !== void 0) {
+      request.addQueryParam("scope", {
+        key: "scope",
+        value: options.scope,
         explode: false,
         encode: true,
         style: "form",
@@ -2020,7 +2495,7 @@ var MemoriesService = class extends BaseService {
   **Array Parameters:**
   - `topics`: Provide as comma-separated values (e.g., `topics=typescript,api-design`)
   
-     * @param q - Search query string
+     * @param q - Search query string. Optional — omit for topic/date-only browsing.
      * @param searchMethod - Search algorithm to use
      * @param limit - Maximum number of results to return
      * @param offset - Number of results to skip for pagination
@@ -2036,6 +2511,7 @@ var MemoriesService = class extends BaseService {
      * @param includeTopics - Include associated topics in results
      * @param includeEntities - Include mentioned entities in results
      * @param includeFacts - Include extracted facts in results
+     * @param includeClaims - Include claims associated with results (defaults to true)
      * @param asOfTime - Point-in-time query (ISO 8601 datetime)
      * @param validAtTime - Filter by validity time (ISO 8601 datetime)
      * @param eventTimeFrom - Event time range start (ISO 8601 datetime)
@@ -2053,6 +2529,13 @@ var MemoriesService = class extends BaseService {
      * @param entityWeight - Weight for entity graph branch in hybrid search
      * @param topicWeight - Weight for topic graph branch in hybrid search
      * @param factWeight - Weight for fact graph branch in hybrid search
+     * @param questionWeight - Weight for question graph branch in hybrid search
+     * @param claimsWeight - Weight for claims vector branch in hybrid search
+     * @param includeFacets - Include facet aggregation (topics, memoryType, effectiveState) in response
+     * @param embeddingProvider - Which embedding provider to use for query-time embedding generation and vector index lookup. `voyage` is the canonical name for the secondary provider (Voyage voyage-3.5, 1024d); `openai` is accepted as a legacy alias and now also resolves to Voyage after v1.66 P0-EMBED-SWAP. Falls back to ollama when the secondary provider is unavailable.
+     * @param scope - Filter by codeContext scope. Comma-separated key:value pairs (e.g. scope=product:memnexus,service:core-api). Memories must match ALL specified scope pairs. Allowed keys, product, service, team, role — unknown keys return 400.
+     * @param taskId - Task-scoped retrieval: returns own-history first, fills remainder with cross-task results.
+     * @param outcomeFilter - Filter by task outcome. Use 'resolved' to find successful approaches from past tasks.
      */
   async searchMemoriesGet(options) {
     const request = new Request({
@@ -2260,6 +2743,18 @@ var MemoriesService = class extends BaseService {
         isCursor: false
       });
     }
+    if (options?.includeClaims !== void 0) {
+      request.addQueryParam("includeClaims", {
+        key: "includeClaims",
+        value: options.includeClaims,
+        explode: false,
+        encode: true,
+        style: "form",
+        isLimit: false,
+        isOffset: false,
+        isCursor: false
+      });
+    }
     if (options?.asOfTime !== void 0) {
       request.addQueryParam("asOfTime", {
         key: "asOfTime",
@@ -2464,6 +2959,90 @@ var MemoriesService = class extends BaseService {
         isCursor: false
       });
     }
+    if (options?.questionWeight !== void 0) {
+      request.addQueryParam("questionWeight", {
+        key: "questionWeight",
+        value: options.questionWeight,
+        explode: false,
+        encode: true,
+        style: "form",
+        isLimit: false,
+        isOffset: false,
+        isCursor: false
+      });
+    }
+    if (options?.claimsWeight !== void 0) {
+      request.addQueryParam("claimsWeight", {
+        key: "claimsWeight",
+        value: options.claimsWeight,
+        explode: false,
+        encode: true,
+        style: "form",
+        isLimit: false,
+        isOffset: false,
+        isCursor: false
+      });
+    }
+    if (options?.includeFacets !== void 0) {
+      request.addQueryParam("includeFacets", {
+        key: "includeFacets",
+        value: options.includeFacets,
+        explode: false,
+        encode: true,
+        style: "form",
+        isLimit: false,
+        isOffset: false,
+        isCursor: false
+      });
+    }
+    if (options?.embeddingProvider !== void 0) {
+      request.addQueryParam("embeddingProvider", {
+        key: "embeddingProvider",
+        value: options.embeddingProvider,
+        explode: false,
+        encode: true,
+        style: "form",
+        isLimit: false,
+        isOffset: false,
+        isCursor: false
+      });
+    }
+    if (options?.scope !== void 0) {
+      request.addQueryParam("scope", {
+        key: "scope",
+        value: options.scope,
+        explode: false,
+        encode: true,
+        style: "form",
+        isLimit: false,
+        isOffset: false,
+        isCursor: false
+      });
+    }
+    if (options?.taskId !== void 0) {
+      request.addQueryParam("taskId", {
+        key: "taskId",
+        value: options.taskId,
+        explode: false,
+        encode: true,
+        style: "form",
+        isLimit: false,
+        isOffset: false,
+        isCursor: false
+      });
+    }
+    if (options?.outcomeFilter !== void 0) {
+      request.addQueryParam("outcomeFilter", {
+        key: "outcomeFilter",
+        value: options.outcomeFilter,
+        explode: false,
+        encode: true,
+        style: "form",
+        isLimit: false,
+        isOffset: false,
+        isCursor: false
+      });
+    }
     return this.client.call(request);
   }
   /**
@@ -2566,6 +3145,41 @@ var MemoriesService = class extends BaseService {
     }
     return this.client.call(request);
   }
+  /**
+     * Generate memory digest (SSE streaming)
+     * Same as POST /api/memories/digest but uses Server-Sent Events (SSE) to stream
+  the response. Sends `: heartbeat` comments every 10 seconds during processing
+  to prevent gateway read-timeout (default 60s) from killing long-running digests.
+  
+  **Event sequence:**
+  - `: heartbeat` — keep-alive comment, sent every 10s during processing
+  - `event: result` / `data: <DigestResponse JSON>` — digest completed successfully
+  - `event: error` / `data: {"error":"...","statusCode":N}` — digest failed
+  - `event: done` / `data: {}` — stream complete (sent after result)
+  
+  **Formats and pipeline:** identical to POST /api/memories/digest.
+  
+     * @param body - Request body
+     */
+  async streamMemoryDigest(body) {
+    const request = new Request({
+      baseUrl: this.config.baseUrl || "http://localhost:3000",
+      method: "POST",
+      path: "/api/memories/digest/stream",
+      config: this.config,
+      retry: {
+        attempts: 3,
+        delayMs: 150,
+        maxDelayMs: 5e3,
+        jitterMs: 50,
+        backoffFactor: 2
+      }
+    });
+    if (body !== void 0) {
+      request.addBody(body);
+    }
+    return this.client.call(request);
+  }
   /**
      * Build a context briefing
      * Answers "What should I know before working on X?" by combining active work
@@ -2600,8 +3214,11 @@ var MemoriesService = class extends BaseService {
   Walks the SUPERSEDES chain from HEAD backwards.
   
      * @param name - Memory name (kebab-case, 2-64 chars)
+     * @param limit - Optional cap on the number of most-recent versions to return.
+  When omitted, the full version chain is returned.
+  
      */
-  async getNamedMemoryHistory(name) {
+  async getNamedMemoryHistory(name, options) {
     const request = new Request({
       baseUrl: this.config.baseUrl || "http://localhost:3000",
       method: "GET",
@@ -2625,6 +3242,18 @@ var MemoriesService = class extends BaseService {
       isOffset: false,
       isCursor: false
     });
+    if (options?.limit !== void 0) {
+      request.addQueryParam("limit", {
+        key: "limit",
+        value: options.limit,
+        explode: false,
+        encode: true,
+        style: "form",
+        isLimit: true,
+        isOffset: false,
+        isCursor: false
+      });
+    }
     return this.client.call(request);
   }
   /**
@@ -2711,6 +3340,56 @@ var MemoriesService = class extends BaseService {
     }
     return this.client.call(request);
   }
+  /**
+     * Bulk delete multiple memories
+     * Soft-delete multiple memories at once. Requires confirmDeletion=true.
+  Each memory is verified to belong to the authenticated user.
+  Maximum 100 IDs per request.
+  
+     * @param body - Request body
+     */
+  async bulkDeleteMemories(body) {
+    const request = new Request({
+      baseUrl: this.config.baseUrl || "http://localhost:3000",
+      method: "DELETE",
+      path: "/api/memories/bulk",
+      config: this.config,
+      retry: {
+        attempts: 3,
+        delayMs: 150,
+        maxDelayMs: 5e3,
+        jitterMs: 50,
+        backoffFactor: 2
+      }
+    });
+    if (body !== void 0) {
+      request.addBody(body);
+    }
+    return this.client.call(request);
+  }
+  /**
+     * Repair orphaned effectiveState values
+     * Finds memories with effectiveState='superseded' or 'contradicted' but no
+  corresponding incoming SUPERSEDES/CONTRADICTS edges, and resets them to 'current'.
+  This handles cases where edges were deleted but effectiveState wasn't recalculated.
+  
+     */
+  async repairEffectiveState() {
+    const request = new Request({
+      baseUrl: this.config.baseUrl || "http://localhost:3000",
+      method: "POST",
+      path: "/api/memories/repair-effective-state",
+      config: this.config,
+      retry: {
+        attempts: 3,
+        delayMs: 150,
+        maxDelayMs: 5e3,
+        jitterMs: 50,
+        backoffFactor: 2
+      }
+    });
+    return this.client.call(request);
+  }
   /**
      * Record behavioral feedback on a search result
      * Record whether a search result was selected or ignored by the user.
@@ -3119,8 +3798,128 @@ var MemoriesService = class extends BaseService {
       isOffset: false,
       isCursor: false
     });
-    if (options?.body !== void 0) {
-      request.addBody(options?.body);
+    if (options?.body !== void 0) {
+      request.addBody(options?.body);
+    }
+    return this.client.call(request);
+  }
+  /**
+     * Generate LLM explanation for a memory relationship
+     * Uses an LLM to explain why two memories have been flagged with a
+  particular relationship (e.g. contradiction). Returns a short
+  plain-text explanation highlighting the specific differences.
+  
+     * @param id - The ID of the source memory
+     * @param body - Request body
+     */
+  async explainMemoryRelationship(id, body) {
+    const request = new Request({
+      baseUrl: this.config.baseUrl || "http://localhost:3000",
+      method: "POST",
+      path: "/api/memories/{id}/explain-relationship",
+      config: this.config,
+      retry: {
+        attempts: 3,
+        delayMs: 150,
+        maxDelayMs: 5e3,
+        jitterMs: 50,
+        backoffFactor: 2
+      }
+    });
+    request.addPathParam("id", {
+      key: "id",
+      value: id,
+      explode: false,
+      encode: true,
+      style: "simple",
+      isLimit: false,
+      isOffset: false,
+      isCursor: false
+    });
+    if (body !== void 0) {
+      request.addBody(body);
+    }
+    return this.client.call(request);
+  }
+  /**
+     * Export memories matching filters
+     * Export memories matching an optional search query and filters to JSON or CSV format.
+  When a query is provided, uses hybrid search. When no query is provided, lists memories
+  with optional topic and memoryType filters. Maximum 1000 results per export.
+  
+     * @param body - Request body
+     */
+  async exportMemories(body) {
+    const request = new Request({
+      baseUrl: this.config.baseUrl || "http://localhost:3000",
+      method: "POST",
+      path: "/api/memories/export",
+      config: this.config,
+      retry: {
+        attempts: 3,
+        delayMs: 150,
+        maxDelayMs: 5e3,
+        jitterMs: 50,
+        backoffFactor: 2
+      }
+    });
+    if (body !== void 0) {
+      request.addBody(body);
+    }
+    return this.client.call(request);
+  }
+  /**
+     * Bulk update multiple memories
+     * Update multiple memories at once. Supports updating topics and memoryType.
+  Each memory is verified to belong to the authenticated user.
+  Maximum 100 IDs per request.
+  
+     * @param body - Request body
+     */
+  async bulkUpdateMemories(body) {
+    const request = new Request({
+      baseUrl: this.config.baseUrl || "http://localhost:3000",
+      method: "POST",
+      path: "/api/memories/bulk-update",
+      config: this.config,
+      retry: {
+        attempts: 3,
+        delayMs: 150,
+        maxDelayMs: 5e3,
+        jitterMs: 50,
+        backoffFactor: 2
+      }
+    });
+    if (body !== void 0) {
+      request.addBody(body);
+    }
+    return this.client.call(request);
+  }
+  /**
+     * Bulk add or remove topics from memories
+     * Add and/or remove topics from multiple memories at once.
+  At least one of addTopics or removeTopics must be provided.
+  Each memory is verified to belong to the authenticated user.
+  Maximum 100 IDs per request.
+  
+     * @param body - Request body
+     */
+  async bulkTagMemories(body) {
+    const request = new Request({
+      baseUrl: this.config.baseUrl || "http://localhost:3000",
+      method: "POST",
+      path: "/api/memories/bulk-tag",
+      config: this.config,
+      retry: {
+        attempts: 3,
+        delayMs: 150,
+        maxDelayMs: 5e3,
+        jitterMs: 50,
+        backoffFactor: 2
+      }
+    });
+    if (body !== void 0) {
+      request.addBody(body);
     }
     return this.client.call(request);
   }
@@ -3182,6 +3981,30 @@ var InvitesService = class extends BaseService {
 
 // src/services/health-service.ts
 var HealthService = class extends BaseService {
+  /**
+     * Liveness probe endpoint
+     * Returns 200 if the process is alive. Does not check external dependencies.
+  Used by Kubernetes liveness probes to determine if the container should be restarted.
+  Unlike /health, this endpoint does not query the database — a database outage
+  should not cause the API process to be killed and restarted.
+  
+     */
+  async livenessCheck() {
+    const request = new Request({
+      baseUrl: this.config.baseUrl || "http://localhost:3000",
+      method: "GET",
+      path: "/livez",
+      config: this.config,
+      retry: {
+        attempts: 3,
+        delayMs: 150,
+        maxDelayMs: 5e3,
+        jitterMs: 50,
+        backoffFactor: 2
+      }
+    });
+    return this.client.call(request);
+  }
   /**
      * API health check endpoint
      * Returns the health status and uptime of the API service.
@@ -3300,6 +4123,7 @@ var FactsService = class extends BaseService {
    * List all facts for the authenticated user
    * @param limit - Maximum number of facts to return
    * @param offset - Number of facts to skip
+   * @param memoryId - Filter facts to a specific memory
    * @param sortBy - Field to sort facts by
    * @param order - Sort order
    */
@@ -3341,6 +4165,18 @@ var FactsService = class extends BaseService {
         isCursor: false
       });
     }
+    if (options?.memoryId !== void 0) {
+      request.addQueryParam("memoryId", {
+        key: "memoryId",
+        value: options.memoryId,
+        explode: false,
+        encode: true,
+        style: "form",
+        isLimit: false,
+        isOffset: false,
+        isCursor: false
+      });
+    }
     if (options?.sortBy !== void 0) {
       request.addQueryParam("sortBy", {
         key: "sortBy",
@@ -3519,6 +4355,7 @@ var EntitiesService = class extends BaseService {
   /**
    * List entities
    * List all entities for the authenticated user, optionally filtered by type
+   * @param query - Search entities by name (case-insensitive substring match)
    * @param type - Filter by entity type (e.g., PERSON, TECHNOLOGY)
    * @param limit - Maximum number of entities to return
    * @param offset - Number of entities to skip
@@ -3537,6 +4374,18 @@ var EntitiesService = class extends BaseService {
         backoffFactor: 2
       }
     });
+    if (options?.query !== void 0) {
+      request.addQueryParam("query", {
+        key: "query",
+        value: options.query,
+        explode: false,
+        encode: true,
+        style: "form",
+        isLimit: false,
+        isOffset: false,
+        isCursor: false
+      });
+    }
     if (options?.type !== void 0) {
       request.addQueryParam("type", {
         key: "type",
@@ -3695,7 +4544,7 @@ var ConversationsService = class extends BaseService {
    * @param since - Return only conversations created after this timestamp (ISO 8601 format)
    * @param sortBy - Field to sort conversations by
    * @param order - Sort order
-   * @param hasMemories - When true, return only conversations that contain at least one memory
+   * @param minMemories - Return only conversations with at least this many memories (filters out empty init conversations)
    */
   async listConversations(options) {
     const request = new Request({
@@ -3771,10 +4620,10 @@ var ConversationsService = class extends BaseService {
         isCursor: false
       });
     }
-    if (options?.hasMemories !== void 0) {
-      request.addQueryParam("hasMemories", {
-        key: "hasMemories",
-        value: options.hasMemories,
+    if (options?.minMemories !== void 0) {
+      request.addQueryParam("minMemories", {
+        key: "minMemories",
+        value: options.minMemories,
         explode: false,
         encode: true,
         style: "form",
@@ -4544,6 +5393,33 @@ var ApiKeysService = class extends BaseService {
   }
 };
 
+// src/services/alerts-service.ts
+var AlertsService = class extends BaseService {
+  /**
+     * List active system alerts for the current user
+     * Returns all active, non-expired system alerts that target either
+  all users or the authenticated user specifically. Used by the
+  customer portal to render the system alerts banner.
+  
+     */
+  async getActiveSystemAlerts() {
+    const request = new Request({
+      baseUrl: this.config.baseUrl || "http://localhost:3000",
+      method: "GET",
+      path: "/api/alerts/active",
+      config: this.config,
+      retry: {
+        attempts: 3,
+        delayMs: 150,
+        maxDelayMs: 5e3,
+        jitterMs: 50,
+        backoffFactor: 2
+      }
+    });
+    return this.client.call(request);
+  }
+};
+
 // src/services/admin-service.ts
 var AdminService = class extends BaseService {
   /**
@@ -4599,22 +5475,232 @@ var AdminService = class extends BaseService {
         encode: true,
         style: "form",
         isLimit: false,
-        isOffset: true,
+        isOffset: true,
+        isCursor: false
+      });
+    }
+    return this.client.call(request);
+  }
+  /**
+   * Create invite code
+   * Create a new invite code for the gated preview
+   * @param body - Request body
+   */
+  async adminCreateInviteCode(body) {
+    const request = new Request({
+      baseUrl: this.config.baseUrl || "http://localhost:3000",
+      method: "POST",
+      path: "/api/admin/invites",
+      config: this.config,
+      retry: {
+        attempts: 3,
+        delayMs: 150,
+        maxDelayMs: 5e3,
+        jitterMs: 50,
+        backoffFactor: 2
+      }
+    });
+    if (body !== void 0) {
+      request.addBody(body);
+    }
+    return this.client.call(request);
+  }
+  /**
+   * Get invite system statistics
+   * Aggregate statistics for the invite system
+   */
+  async adminGetInviteStats() {
+    const request = new Request({
+      baseUrl: this.config.baseUrl || "http://localhost:3000",
+      method: "GET",
+      path: "/api/admin/invites/stats",
+      config: this.config,
+      retry: {
+        attempts: 3,
+        delayMs: 150,
+        maxDelayMs: 5e3,
+        jitterMs: 50,
+        backoffFactor: 2
+      }
+    });
+    return this.client.call(request);
+  }
+  /**
+   * Get invite code details
+   * Get details for a single invite code including redemptions
+   * @param code - The invite code
+   */
+  async adminGetInviteCode(code) {
+    const request = new Request({
+      baseUrl: this.config.baseUrl || "http://localhost:3000",
+      method: "GET",
+      path: "/api/admin/invites/{code}",
+      config: this.config,
+      retry: {
+        attempts: 3,
+        delayMs: 150,
+        maxDelayMs: 5e3,
+        jitterMs: 50,
+        backoffFactor: 2
+      }
+    });
+    request.addPathParam("code", {
+      key: "code",
+      value: code,
+      explode: false,
+      encode: true,
+      style: "simple",
+      isLimit: false,
+      isOffset: false,
+      isCursor: false
+    });
+    return this.client.call(request);
+  }
+  /**
+   * Revoke an invite code
+   * Revoke an invite code. Existing accounts created with this code are unaffected.
+   * @param code - 
+   */
+  async adminRevokeInviteCode(code) {
+    const request = new Request({
+      baseUrl: this.config.baseUrl || "http://localhost:3000",
+      method: "DELETE",
+      path: "/api/admin/invites/{code}",
+      config: this.config,
+      retry: {
+        attempts: 3,
+        delayMs: 150,
+        maxDelayMs: 5e3,
+        jitterMs: 50,
+        backoffFactor: 2
+      }
+    });
+    request.addPathParam("code", {
+      key: "code",
+      value: code,
+      explode: false,
+      encode: true,
+      style: "simple",
+      isLimit: false,
+      isOffset: false,
+      isCursor: false
+    });
+    return this.client.call(request);
+  }
+  /**
+   * Get gate status with audit info
+   * Get current invite gate state with audit information
+   */
+  async adminGetGateStatus() {
+    const request = new Request({
+      baseUrl: this.config.baseUrl || "http://localhost:3000",
+      method: "GET",
+      path: "/api/admin/gate",
+      config: this.config,
+      retry: {
+        attempts: 3,
+        delayMs: 150,
+        maxDelayMs: 5e3,
+        jitterMs: 50,
+        backoffFactor: 2
+      }
+    });
+    return this.client.call(request);
+  }
+  /**
+     * Toggle invite gate
+     * Toggle the invite gate. When enabled (true), new signups require a valid invite code.
+  When disabled (false), registration is open. Takes effect immediately.
+  
+     * @param body - Request body
+     */
+  async adminSetGateStatus(body) {
+    const request = new Request({
+      baseUrl: this.config.baseUrl || "http://localhost:3000",
+      method: "POST",
+      path: "/api/admin/gate",
+      config: this.config,
+      retry: {
+        attempts: 3,
+        delayMs: 150,
+        maxDelayMs: 5e3,
+        jitterMs: 50,
+        backoffFactor: 2
+      }
+    });
+    if (body !== void 0) {
+      request.addBody(body);
+    }
+    return this.client.call(request);
+  }
+  /**
+   * Backfill per-stage memory pipeline status fields by inspecting actual graph state
+   * @param body - Request body
+   */
+  async adminMigratePerStageStatus(options) {
+    const request = new Request({
+      baseUrl: this.config.baseUrl || "http://localhost:3000",
+      method: "POST",
+      path: "/api/admin/migrate/per-stage-status",
+      config: this.config,
+      retry: {
+        attempts: 3,
+        delayMs: 150,
+        maxDelayMs: 5e3,
+        jitterMs: 50,
+        backoffFactor: 2
+      }
+    });
+    if (options?.body !== void 0) {
+      request.addBody(options?.body);
+    }
+    return this.client.call(request);
+  }
+};
+
+// src/services/admin-alerts-service.ts
+var AdminAlertsService = class extends BaseService {
+  /**
+   * List system alerts
+   * @param activeOnly - If true, return only active, non-expired alerts.
+   */
+  async adminListSystemAlerts(options) {
+    const request = new Request({
+      baseUrl: this.config.baseUrl || "http://localhost:3000",
+      method: "GET",
+      path: "/api/admin/alerts",
+      config: this.config,
+      retry: {
+        attempts: 3,
+        delayMs: 150,
+        maxDelayMs: 5e3,
+        jitterMs: 50,
+        backoffFactor: 2
+      }
+    });
+    if (options?.activeOnly !== void 0) {
+      request.addQueryParam("activeOnly", {
+        key: "activeOnly",
+        value: options.activeOnly,
+        explode: false,
+        encode: true,
+        style: "form",
+        isLimit: false,
+        isOffset: false,
         isCursor: false
       });
     }
     return this.client.call(request);
   }
   /**
-   * Create invite code
-   * Create a new invite code for the gated preview
+   * Create a system alert
    * @param body - Request body
    */
-  async adminCreateInviteCode(body) {
+  async adminCreateSystemAlert(body) {
     const request = new Request({
       baseUrl: this.config.baseUrl || "http://localhost:3000",
       method: "POST",
-      path: "/api/admin/invites",
+      path: "/api/admin/alerts",
       config: this.config,
       retry: {
         attempts: 3,
@@ -4630,14 +5716,14 @@ var AdminService = class extends BaseService {
     return this.client.call(request);
   }
   /**
-   * Get invite system statistics
-   * Aggregate statistics for the invite system
+   * Get a system alert by id
+   * @param id - System alert id
    */
-  async adminGetInviteStats() {
+  async adminGetSystemAlert(id) {
     const request = new Request({
       baseUrl: this.config.baseUrl || "http://localhost:3000",
       method: "GET",
-      path: "/api/admin/invites/stats",
+      path: "/api/admin/alerts/{id}",
       config: this.config,
       retry: {
         attempts: 3,
@@ -4647,18 +5733,27 @@ var AdminService = class extends BaseService {
         backoffFactor: 2
       }
     });
+    request.addPathParam("id", {
+      key: "id",
+      value: id,
+      explode: false,
+      encode: true,
+      style: "simple",
+      isLimit: false,
+      isOffset: false,
+      isCursor: false
+    });
     return this.client.call(request);
   }
   /**
-   * Get invite code details
-   * Get details for a single invite code including redemptions
-   * @param code - The invite code
+   * Delete a system alert
+   * @param id - System alert id
    */
-  async adminGetInviteCode(code) {
+  async adminDeleteSystemAlert(id) {
     const request = new Request({
       baseUrl: this.config.baseUrl || "http://localhost:3000",
-      method: "GET",
-      path: "/api/admin/invites/{code}",
+      method: "DELETE",
+      path: "/api/admin/alerts/{id}",
       config: this.config,
       retry: {
         attempts: 3,
@@ -4668,9 +5763,9 @@ var AdminService = class extends BaseService {
         backoffFactor: 2
       }
     });
-    request.addPathParam("code", {
-      key: "code",
-      value: code,
+    request.addPathParam("id", {
+      key: "id",
+      value: id,
       explode: false,
       encode: true,
       style: "simple",
@@ -4681,15 +5776,15 @@ var AdminService = class extends BaseService {
     return this.client.call(request);
   }
   /**
-   * Revoke an invite code
-   * Revoke an invite code. Existing accounts created with this code are unaffected.
-   * @param code - 
+   * Update a system alert
+   * @param id - 
+   * @param body - Request body
    */
-  async adminRevokeInviteCode(code) {
+  async adminUpdateSystemAlert(id, body) {
     const request = new Request({
       baseUrl: this.config.baseUrl || "http://localhost:3000",
-      method: "DELETE",
-      path: "/api/admin/invites/{code}",
+      method: "PATCH",
+      path: "/api/admin/alerts/{id}",
       config: this.config,
       retry: {
         attempts: 3,
@@ -4699,9 +5794,9 @@ var AdminService = class extends BaseService {
         backoffFactor: 2
       }
     });
-    request.addPathParam("code", {
-      key: "code",
-      value: code,
+    request.addPathParam("id", {
+      key: "id",
+      value: id,
       explode: false,
       encode: true,
       style: "simple",
@@ -4709,17 +5804,30 @@ var AdminService = class extends BaseService {
       isOffset: false,
       isCursor: false
     });
+    if (body !== void 0) {
+      request.addBody(body);
+    }
     return this.client.call(request);
   }
-  /**
-   * Get gate status with audit info
-   * Get current invite gate state with audit information
-   */
-  async adminGetGateStatus() {
+};
+
+// src/services/admin-pipeline-service.ts
+var AdminPipelineService = class extends BaseService {
+  /**
+     * Re-enqueue a single memory through one pipeline
+     * Admin-only. Re-publishes the requested pipeline job for the given
+  memory and resets the corresponding per-stage status field(s) to
+  `queued`. Used to recover individual memories from transient
+  worker failures or to replay a stage after a code change.
+  
+     * @param id - Memory id (admin can target any tenant).
+     * @param body - Request body
+     */
+  async adminRerunMemoryPipeline(id, body) {
     const request = new Request({
       baseUrl: this.config.baseUrl || "http://localhost:3000",
-      method: "GET",
-      path: "/api/admin/gate",
+      method: "POST",
+      path: "/api/admin/memories/{id}/rerun",
       config: this.config,
       retry: {
         attempts: 3,
@@ -4729,20 +5837,34 @@ var AdminService = class extends BaseService {
         backoffFactor: 2
       }
     });
+    request.addPathParam("id", {
+      key: "id",
+      value: id,
+      explode: false,
+      encode: true,
+      style: "simple",
+      isLimit: false,
+      isOffset: false,
+      isCursor: false
+    });
+    if (body !== void 0) {
+      request.addBody(body);
+    }
     return this.client.call(request);
   }
   /**
-     * Toggle invite gate
-     * Toggle the invite gate. When enabled (true), new signups require a valid invite code.
-  When disabled (false), registration is open. Takes effect immediately.
+     * Per-queue depth + failure counts for the memory-creation pipelines
+     * Returns BullMQ `getJobCounts()` for each known pipeline queue. Queues
+  that have not yet been provisioned (e.g. `summary-qna` while task 2.3
+  is in flight) are reported with `{ status: "not_configured" }` rather
+  than throwing.
   
-     * @param body - Request body
      */
-  async adminSetGateStatus(body) {
+  async adminGetPipelineHealth() {
     const request = new Request({
       baseUrl: this.config.baseUrl || "http://localhost:3000",
-      method: "POST",
-      path: "/api/admin/gate",
+      method: "GET",
+      path: "/api/admin/pipeline/health",
       config: this.config,
       retry: {
         attempts: 3,
@@ -4752,9 +5874,37 @@ var AdminService = class extends BaseService {
         backoffFactor: 2
       }
     });
-    if (body !== void 0) {
-      request.addBody(body);
-    }
+    return this.client.call(request);
+  }
+  /**
+   * Inspect per-stage pipeline status for a single memory
+   * Debugging affordance — returns the six per-stage status fields and graphSkipReason.
+   * @param id - 
+   */
+  async adminGetMemoryPipelineStatus(id) {
+    const request = new Request({
+      baseUrl: this.config.baseUrl || "http://localhost:3000",
+      method: "GET",
+      path: "/api/admin/memories/{id}/pipeline-status",
+      config: this.config,
+      retry: {
+        attempts: 3,
+        delayMs: 150,
+        maxDelayMs: 5e3,
+        jitterMs: 50,
+        backoffFactor: 2
+      }
+    });
+    request.addPathParam("id", {
+      key: "id",
+      value: id,
+      explode: false,
+      encode: true,
+      style: "simple",
+      isLimit: false,
+      isOffset: false,
+      isCursor: false
+    });
     return this.client.call(request);
   }
 };
@@ -4763,7 +5913,9 @@ var AdminService = class extends BaseService {
 import { z } from "zod";
 var error = z.object({
   /** Error message */
-  error: z.string()
+  error: z.string(),
+  /** Optional constructor name of the underlying error. Present on selected 500 responses for client diagnostics; absent on most error responses. */
+  errorClass: z.string().optional()
 });
 var pagination = z.object({
   /** Maximum number of items per page */
@@ -4773,7 +5925,23 @@ var pagination = z.object({
   /** Total number of items */
   count: z.number().min(0)
 });
-var memory = z.object({
+var codeContext = z.object({
+  /** Product name (e.g. 'memnexus', 'spearmint') */
+  product: z.string().max(200).optional(),
+  /** Repository name, if different from product */
+  repo: z.string().max(200).optional(),
+  /** Service or package name (e.g. 'core-api', 'mcp-server', 'cli') */
+  service: z.string().max(200).optional(),
+  /** Subsystem or component (e.g. 'extraction-pipeline', 'search', 'billing') */
+  component: z.string().max(200).optional(),
+  /** Team that produced this knowledge (e.g. 'extraction', 'mcp', 'platform') */
+  team: z.string().max(200).optional(),
+  /** Agent role or persona (e.g. 'team-lead', 'implementer', 'reviewer') */
+  role: z.string().max(200).optional(),
+  /** Additional project-specific scope tags */
+  extra: z.object({}).catchall(z.string().max(500)).optional()
+}).nullable();
+var memory = z.lazy(() => z.object({
   /** Unique memory identifier */
   id: z.string(),
   /** Optional human-readable name for deterministic retrieval. Only the HEAD version carries the name. */
@@ -4796,6 +5964,8 @@ var memory = z.object({
   validFrom: z.string().datetime().optional(),
   /** Validity end time (when this fact expires, null means never expires) */
   validTo: z.string().datetime().nullable().optional(),
+  /** Environment context for memory scoping — product, service, team, component, role. */
+  codeContext: codeContext.optional(),
   /** Creation timestamp */
   createdAt: z.string().datetime(),
   /** Last update timestamp */
@@ -4805,23 +5975,57 @@ var memory = z.object({
   /** Basis for the confidence score */
   confidenceBasis: z.enum(["direct-statement", "repeated-mention", "single-mention", "hedged", "inference", "external-source", "contradicted"]).optional(),
   /** Effective state of the memory in the narrative */
-  effectiveState: z.enum(["current", "superseded", "contradicted"]).optional(),
-  /** Status of automatic content extraction */
-  extractionStatus: z.enum(["pending", "completed", "failed", "skipped"]).optional(),
+  effectiveState: z.enum(["current", "superseded", "contradicted", "duplicate"]).optional(),
+  /** Authority level: directive (mandates) > decision (choices with reasoning) > observation (learned during work) > auto-captured (generated content) */
+  authority: z.enum(["directive", "decision", "observation", "auto-captured"]).optional(),
+  /** Legacy aggregate extraction status. DERIVED on read from the six per-stage statuses (contentEmbeddingStatus, summaryStatus, questionsStatus, summaryEmbeddingStatus, questionsEmbeddingStatus, graphStatus). Preserved for SDK compatibility per PRD memory-creation-pipeline-v2 §5 Q7. */
+  extractionStatus: z.enum(["pending", "queued", "running", "completed", "failed", "skipped"]).optional(),
   /** When extraction was completed */
   extractionCompletedAt: z.string().datetime().optional(),
+  /** Pipeline 2 content-embedding stage status. Tracks the queue lifecycle for writing m.embedding (primary content embedding). */
+  contentEmbeddingStatus: z.enum(["pending", "queued", "running", "completed", "failed", "skipped"]).optional(),
+  /** AI-generated summary of the memory content */
+  summary: z.string().optional(),
+  /** Pipeline 1 summary stage status. Tracks generation of m.summary by the summary-qna LLM call. */
+  summaryStatus: z.enum(["pending", "queued", "running", "completed", "failed", "skipped"]).optional(),
+  /** Pipeline 1 questions stage status. Tracks generation of anticipated Question nodes by the summary-qna LLM call. */
+  questionsStatus: z.enum(["pending", "queued", "running", "completed", "failed", "skipped"]).optional(),
+  /** Pipeline 2 summary-embedding stage status. Tracks the queue lifecycle for writing m.summaryEmbedding (depends on summaryStatus=completed). */
+  summaryEmbeddingStatus: z.enum(["pending", "queued", "running", "completed", "failed", "skipped"]).optional(),
+  /** Pipeline 2 question-embedding stage status. Tracks the queue lifecycle for writing Question.embedding for each anticipated question (depends on questionsStatus=completed). */
+  questionsEmbeddingStatus: z.enum(["pending", "queued", "running", "completed", "failed", "skipped"]).optional(),
+  /** Pipeline 3 graph-extraction stage status. Tracks generation of entities, facts, topics, authority, and memory-type. Replaces the role formerly played by the monolithic extractionStatus writer. */
+  graphStatus: z.enum(["pending", "queued", "running", "completed", "failed", "skipped"]).optional(),
+  /** When graphStatus=skipped, records why graph extraction was skipped. Mirrors the legacy extractionSkipReason field but scoped to the graph pipeline. */
+  graphSkipReason: z.enum(["global_disabled", "plan_excluded", "user_opt_out", "content_too_short", "legacy", "budget_exhausted"]).nullable().optional(),
+  /** When extractionStatus=skipped, records why extraction was skipped. global_disabled = GRAPH_EXTRACTION_ENABLED=false kill switch. */
+  extractionSkipReason: z.enum(["global_disabled", "plan_excluded", "user_opt_out", "content_too_short", "legacy"]).optional(),
+  /** Status of primary (Ollama) embedding generation via durable queue */
+  embeddingStatus: z.enum(["queued", "running", "completed", "failed", "skipped"]).optional(),
+  /** Status of secondary (OpenAI) dual-write embedding generation via durable queue */
+  embeddingOpenaiStatus: z.enum(["queued", "running", "completed", "failed", "skipped"]).optional(),
+  /** True if the primary content embedding used a head-truncated input (model context exceeded). */
+  embeddingTruncated: z.boolean().optional(),
+  /** Token count of the original content (pre-truncation, cl100k proxy). Useful for identifying under-indexed memories. */
+  embeddingOriginalTokens: z.number().min(0).optional(),
+  /** Smart-field strategy used to produce the primary content embedding. */
+  embeddingStrategy: z.enum(["full", "head-truncated", "summary-selected", "question-selected"]).optional(),
   /** Number of topics extracted from content */
   extractedTopicCount: z.number().min(0).optional(),
   /** Number of facts extracted from content */
   extractedFactCount: z.number().min(0).optional(),
   /** Number of entities extracted from content */
   extractedEntityCount: z.number().min(0).optional(),
+  /** Number of memories this memory contradicts via outgoing CONTRADICTS relationships */
+  conflictCount: z.number().min(0).optional(),
+  /** Memory visibility level. Null/undefined treated as 'private' for backward compatibility. 'admin_visible' is computed at retrieval time when an org owner/admin queries another member's post-join memory and is never accepted on writes. */
+  visibility: z.enum(["private", "shared_with_users", "shared_with_org", "admin_visible"]).optional(),
+  /** User IDs this memory is shared with (only populated when visibility = 'shared_with_users') */
+  sharedWith: z.array(z.string()).optional(),
   /** Topics explicitly provided by the user */
   userTopics: z.array(z.string()).optional(),
   /** Topics automatically extracted from content */
   extractedTopics: z.array(z.string()).optional(),
-  /** Agent session ID that created this memory (MCP session ID or CLI session UUID). Used to group memories by agent instance for conversation threading. */
-  agentSessionId: z.string().nullable().optional(),
   /** Entities extracted from memory content */
   entities: z.array(z.object({
     /** Entity name */
@@ -4830,13 +6034,41 @@ var memory = z.object({
     type: z.string(),
     /** Extraction confidence */
     confidence: z.number().min(0).max(1).optional()
-  })).optional()
+  })).optional(),
+  /** Task identifier for agentic loop memories */
+  taskId: z.string().nullable().optional(),
+  /** Task outcome status */
+  outcome: z.enum(["resolved", "unresolved"]).nullable().optional(),
+  /** Attempt number within the task */
+  attemptNumber: z.number().nullable().optional(),
+  /** Distillation pipeline stage status */
+  distillStatus: z.enum(["pending", "queued", "running", "completed", "failed", "skipped"]).nullable().optional(),
+  /** Reason distillation was skipped */
+  distillSkipReason: z.enum(["global_disabled", "plan_excluded", "user_opt_out", "content_too_short", "legacy", "budget_exhausted"]).nullable().optional(),
+  /** Error message if distillation failed */
+  distillError: z.string().nullable().optional(),
+  /** ISO 8601 timestamp when distillation completed */
+  distillCompletedAt: z.string().nullable().optional()
+}));
+var precomputedMemoryFields = z.object({
+  /** Pre-computed memory summary. When supplied, summary-qna LLM call is skipped and m.summary is set inline. */
+  summary: z.string().max(2e3).optional(),
+  /** Pre-computed anticipated questions. When supplied, the questions stage of the summary-qna LLM call is skipped and Question nodes are created inline. Hard-capped at 20. */
+  questions: z.array(z.string().max(500)).max(20).optional(),
+  /** Pre-computed embeddings keyed by Pipeline 2 job kind (content / summary / question). */
+  embeddings: z.object({
+    /** Pre-computed content embedding (m.embedding). Bypasses the content-embedding queue. */
+    content: z.array(z.number()).optional(),
+    /** Pre-computed summary embedding (m.summaryEmbedding). Bypasses the summary-embedding queue. */
+    summary: z.array(z.number()).optional(),
+    /** Pre-computed per-question embeddings — must have the same length as `questions` when both are supplied. */
+    questions: z.array(z.array(z.number())).optional()
+  }).optional()
 });
-var createMemoryRequest = z.object({
-  /** Conversation ID - use "NEW" to create a new conversation or provide existing conversation ID */
-  conversationId: z.string().min(1),
-  /** Agent session ID (e.g. MCP session ID, Claude Code session UUID). When provided with conversationId "NEW", reuses the existing conversation for this session instead of creating a new one. Works with any MCP client (Claude, Copilot, Cursor, etc.). */
-  agentSessionId: z.string().max(200).optional(),
+var createMemoryRequest = z.lazy(() => z.object({
+  /** Conversation ID - use "NEW" to always create a new conversation, provide an existing ID to append to it, or omit to auto-assign via claudeSessionId session grouping. */
+  conversationId: z.string().min(1).optional(),
+  /** Agent session ID (e.g. MCP session ID, Claude Code session UUID). When conversationId is omitted, reuses or creates a conversation for this session (automatic grouping). Ignored when conversationId is explicitly provided. Works with any MCP client (Claude, Copilot, Cursor, etc.). */
   claudeSessionId: z.string().max(200).optional(),
   /** Optional human-readable name for deterministic retrieval. Must be unique per user. */
   name: z.string().regex(/^[a-z0-9][a-z0-9-]{0,62}[a-z0-9]$/).optional(),
@@ -4855,8 +6087,32 @@ var createMemoryRequest = z.object({
   /** Validity start time (when this fact becomes valid, ISO 8601 format) */
   validFrom: z.string().datetime().optional(),
   /** Validity end time (when this fact expires, ISO 8601 format, omit for never expires) */
-  validTo: z.string().datetime().optional()
-});
+  validTo: z.string().datetime().optional(),
+  codeContext: z.object({
+    /** Product name (e.g. 'memnexus', 'spearmint') */
+    product: z.string().max(200).optional(),
+    /** Repository name, if different from product */
+    repo: z.string().max(200).optional(),
+    /** Service or package name (e.g. 'core-api', 'mcp-server', 'cli') */
+    service: z.string().max(200).optional(),
+    /** Subsystem or component (e.g. 'extraction-pipeline', 'search', 'billing') */
+    component: z.string().max(200).optional(),
+    /** Team that produced this knowledge (e.g. 'extraction', 'mcp', 'platform') */
+    team: z.string().max(200).optional(),
+    /** Agent role or persona (e.g. 'team-lead', 'implementer', 'reviewer') */
+    role: z.string().max(200).optional(),
+    /** Additional project-specific scope tags */
+    extra: z.object({}).catchall(z.string().max(500)).optional()
+  }).optional(),
+  /** Privileged-only short-circuit for Pipeline 1/2 — admin/internal/test callers may pre-supply summary, questions, and/or embeddings to bypass LLM and embedding work at create time. Silently ignored for non-privileged callers. */
+  precomputed: precomputedMemoryFields.optional(),
+  /** Task identifier for grouping memories across agentic loop attempts */
+  taskId: z.string().max(200).optional(),
+  /** Task outcome status for this memory */
+  outcome: z.enum(["resolved", "unresolved"]).optional(),
+  /** Request distillation of this memory (Pro/Enterprise only) */
+  distill: z.boolean().optional()
+}));
 var updateMemoryRequest = z.object({
   /** Updated memory content */
   content: z.string().min(1).max(5e4).optional(),
@@ -4867,7 +6123,9 @@ var updateMemoryRequest = z.object({
   /** Updated context or domain */
   context: z.string().max(200).optional(),
   /** Updated topics */
-  topics: z.array(z.string().max(100)).max(50).optional()
+  topics: z.array(z.string().max(100)).max(50).optional(),
+  /** Task outcome status. Set to null to clear. */
+  outcome: z.enum(["resolved", "unresolved"]).nullable().optional()
 });
 var createMemoryResponseMeta = z.object({
   /** Conversation ID (actual ID if "NEW" was provided) */
@@ -4883,7 +6141,7 @@ var createMemoryResponse = z.lazy(() => z.object({
   data: memory,
   meta: createMemoryResponseMeta
 }));
-var relatedMemoryResult = z.object({
+var relatedMemoryResult = z.lazy(() => z.object({
   memory: z.object({
     /** Unique memory identifier */
     id: z.string(),
@@ -4907,6 +6165,8 @@ var relatedMemoryResult = z.object({
     validFrom: z.string().datetime().optional(),
     /** Validity end time (when this fact expires, null means never expires) */
     validTo: z.string().datetime().nullable().optional(),
+    /** Environment context for memory scoping — product, service, team, component, role. */
+    codeContext: codeContext.optional(),
     /** Creation timestamp */
     createdAt: z.string().datetime(),
     /** Last update timestamp */
@@ -4916,23 +6176,57 @@ var relatedMemoryResult = z.object({
     /** Basis for the confidence score */
     confidenceBasis: z.enum(["direct-statement", "repeated-mention", "single-mention", "hedged", "inference", "external-source", "contradicted"]).optional(),
     /** Effective state of the memory in the narrative */
-    effectiveState: z.enum(["current", "superseded", "contradicted"]).optional(),
-    /** Status of automatic content extraction */
-    extractionStatus: z.enum(["pending", "completed", "failed", "skipped"]).optional(),
+    effectiveState: z.enum(["current", "superseded", "contradicted", "duplicate"]).optional(),
+    /** Authority level: directive (mandates) > decision (choices with reasoning) > observation (learned during work) > auto-captured (generated content) */
+    authority: z.enum(["directive", "decision", "observation", "auto-captured"]).optional(),
+    /** Legacy aggregate extraction status. DERIVED on read from the six per-stage statuses (contentEmbeddingStatus, summaryStatus, questionsStatus, summaryEmbeddingStatus, questionsEmbeddingStatus, graphStatus). Preserved for SDK compatibility per PRD memory-creation-pipeline-v2 §5 Q7. */
+    extractionStatus: z.enum(["pending", "queued", "running", "completed", "failed", "skipped"]).optional(),
     /** When extraction was completed */
     extractionCompletedAt: z.string().datetime().optional(),
+    /** Pipeline 2 content-embedding stage status. Tracks the queue lifecycle for writing m.embedding (primary content embedding). */
+    contentEmbeddingStatus: z.enum(["pending", "queued", "running", "completed", "failed", "skipped"]).optional(),
+    /** AI-generated summary of the memory content */
+    summary: z.string().optional(),
+    /** Pipeline 1 summary stage status. Tracks generation of m.summary by the summary-qna LLM call. */
+    summaryStatus: z.enum(["pending", "queued", "running", "completed", "failed", "skipped"]).optional(),
+    /** Pipeline 1 questions stage status. Tracks generation of anticipated Question nodes by the summary-qna LLM call. */
+    questionsStatus: z.enum(["pending", "queued", "running", "completed", "failed", "skipped"]).optional(),
+    /** Pipeline 2 summary-embedding stage status. Tracks the queue lifecycle for writing m.summaryEmbedding (depends on summaryStatus=completed). */
+    summaryEmbeddingStatus: z.enum(["pending", "queued", "running", "completed", "failed", "skipped"]).optional(),
+    /** Pipeline 2 question-embedding stage status. Tracks the queue lifecycle for writing Question.embedding for each anticipated question (depends on questionsStatus=completed). */
+    questionsEmbeddingStatus: z.enum(["pending", "queued", "running", "completed", "failed", "skipped"]).optional(),
+    /** Pipeline 3 graph-extraction stage status. Tracks generation of entities, facts, topics, authority, and memory-type. Replaces the role formerly played by the monolithic extractionStatus writer. */
+    graphStatus: z.enum(["pending", "queued", "running", "completed", "failed", "skipped"]).optional(),
+    /** When graphStatus=skipped, records why graph extraction was skipped. Mirrors the legacy extractionSkipReason field but scoped to the graph pipeline. */
+    graphSkipReason: z.enum(["global_disabled", "plan_excluded", "user_opt_out", "content_too_short", "legacy", "budget_exhausted"]).nullable().optional(),
+    /** When extractionStatus=skipped, records why extraction was skipped. global_disabled = GRAPH_EXTRACTION_ENABLED=false kill switch. */
+    extractionSkipReason: z.enum(["global_disabled", "plan_excluded", "user_opt_out", "content_too_short", "legacy"]).optional(),
+    /** Status of primary (Ollama) embedding generation via durable queue */
+    embeddingStatus: z.enum(["queued", "running", "completed", "failed", "skipped"]).optional(),
+    /** Status of secondary (OpenAI) dual-write embedding generation via durable queue */
+    embeddingOpenaiStatus: z.enum(["queued", "running", "completed", "failed", "skipped"]).optional(),
+    /** True if the primary content embedding used a head-truncated input (model context exceeded). */
+    embeddingTruncated: z.boolean().optional(),
+    /** Token count of the original content (pre-truncation, cl100k proxy). Useful for identifying under-indexed memories. */
+    embeddingOriginalTokens: z.number().min(0).optional(),
+    /** Smart-field strategy used to produce the primary content embedding. */
+    embeddingStrategy: z.enum(["full", "head-truncated", "summary-selected", "question-selected"]).optional(),
     /** Number of topics extracted from content */
     extractedTopicCount: z.number().min(0).optional(),
     /** Number of facts extracted from content */
     extractedFactCount: z.number().min(0).optional(),
     /** Number of entities extracted from content */
     extractedEntityCount: z.number().min(0).optional(),
+    /** Number of memories this memory contradicts via outgoing CONTRADICTS relationships */
+    conflictCount: z.number().min(0).optional(),
+    /** Memory visibility level. Null/undefined treated as 'private' for backward compatibility. 'admin_visible' is computed at retrieval time when an org owner/admin queries another member's post-join memory and is never accepted on writes. */
+    visibility: z.enum(["private", "shared_with_users", "shared_with_org", "admin_visible"]).optional(),
+    /** User IDs this memory is shared with (only populated when visibility = 'shared_with_users') */
+    sharedWith: z.array(z.string()).optional(),
     /** Topics explicitly provided by the user */
     userTopics: z.array(z.string()).optional(),
     /** Topics automatically extracted from content */
     extractedTopics: z.array(z.string()).optional(),
-    /** Agent session ID that created this memory (MCP session ID or CLI session UUID). Used to group memories by agent instance for conversation threading. */
-    agentSessionId: z.string().nullable().optional(),
     /** Entities extracted from memory content */
     entities: z.array(z.object({
       /** Entity name */
@@ -4941,7 +6235,21 @@ var relatedMemoryResult = z.object({
       type: z.string(),
       /** Extraction confidence */
       confidence: z.number().min(0).max(1).optional()
-    })).optional()
+    })).optional(),
+    /** Task identifier for agentic loop memories */
+    taskId: z.string().nullable().optional(),
+    /** Task outcome status */
+    outcome: z.enum(["resolved", "unresolved"]).nullable().optional(),
+    /** Attempt number within the task */
+    attemptNumber: z.number().nullable().optional(),
+    /** Distillation pipeline stage status */
+    distillStatus: z.enum(["pending", "queued", "running", "completed", "failed", "skipped"]).nullable().optional(),
+    /** Reason distillation was skipped */
+    distillSkipReason: z.enum(["global_disabled", "plan_excluded", "user_opt_out", "content_too_short", "legacy", "budget_exhausted"]).nullable().optional(),
+    /** Error message if distillation failed */
+    distillError: z.string().nullable().optional(),
+    /** ISO 8601 timestamp when distillation completed */
+    distillCompletedAt: z.string().nullable().optional()
   }),
   /** Relevance score (0-1). For similar: semantic similarity. For related: topic overlap ratio. For conversation: position score. */
   score: z.number().min(0).max(1),
@@ -4949,7 +6257,7 @@ var relatedMemoryResult = z.object({
   relationship: z.string(),
   /** Topics shared with the source memory (only for topic relationship) */
   sharedTopics: z.array(z.string()).optional()
-});
+}));
 var getMemoryResponse = z.lazy(() => z.object({
   data: memory
 }));
@@ -4961,7 +6269,27 @@ var updateNamedMemoryRequest = z.object({
   /** Context or domain */
   context: z.string().max(200).optional(),
   /** Associated topics */
-  topics: z.array(z.string().max(100)).max(50).optional()
+  topics: z.array(z.string().max(100)).max(50).optional(),
+  /** Conversation to group this version with (overrides previous version's conversation) */
+  conversationId: z.string().max(200).optional(),
+  codeContext: z.object({
+    /** Product name (e.g. 'memnexus', 'spearmint') */
+    product: z.string().max(200).optional(),
+    /** Repository name, if different from product */
+    repo: z.string().max(200).optional(),
+    /** Service or package name (e.g. 'core-api', 'mcp-server', 'cli') */
+    service: z.string().max(200).optional(),
+    /** Subsystem or component (e.g. 'extraction-pipeline', 'search', 'billing') */
+    component: z.string().max(200).optional(),
+    /** Team that produced this knowledge (e.g. 'extraction', 'mcp', 'platform') */
+    team: z.string().max(200).optional(),
+    /** Agent role or persona (e.g. 'team-lead', 'implementer', 'reviewer') */
+    role: z.string().max(200).optional(),
+    /** Additional project-specific scope tags */
+    extra: z.object({}).catchall(z.string().max(500)).optional()
+  }).optional(),
+  /** Additional memory ID that this version supersedes (beyond the implicit version chain) */
+  supersedes: z.string().uuid().optional()
 });
 var namedMemoryHistoryResponse = z.object({
   /** Human-readable name for deterministic retrieval (kebab-case, 2-64 chars) */
@@ -4974,16 +6302,16 @@ var namedMemoryHistoryResponse = z.object({
     /** Memory content at this version */
     content: z.string(),
     /** Effective state — HEAD version is 'current', older versions are 'superseded' */
-    effectiveState: z.enum(["current", "superseded", "contradicted"]).optional(),
+    effectiveState: z.enum(["current", "superseded", "contradicted", "duplicate"]).optional(),
     /** When this version was created */
     createdAt: z.string().datetime()
   }))
 });
 var batchGetMemoriesRequest = z.object({
-  /** Array of memory IDs to retrieve */
-  ids: z.array(z.string().uuid()).min(1).max(100),
-  /** Detail level for each memory. 'minimal' returns raw memory only (default, backward compatible). 'standard' adds topics, entities, facts, and relationships. */
-  detail: z.enum(["minimal", "standard"]).optional()
+  /** Array of memory IDs to retrieve. Non-existent or malformed IDs are returned in the 'missing' array rather than failing the request. */
+  ids: z.array(z.string().min(1).max(200)).min(1).max(100),
+  /** Detail level for each memory. 'minimal' returns raw memory only (default, backward compatible). 'standard' adds topics, entities, facts, and relationships. 'full' additionally adds conversation context and relationship target previews. */
+  detail: z.enum(["minimal", "standard", "full"]).optional()
 });
 var batchGetMemoriesMeta = z.object({
   /** Number of IDs requested */
@@ -5084,6 +6412,73 @@ var pattern = z.object({
   /** Confidence score (0-1) */
   confidence: z.number().min(0).max(1)
 });
+var compileInstructionsRequest = z.object({
+  conversationContext: z.array(z.string().max(100)).max(20).optional(),
+  currentQuery: z.string().max(2e3).optional(),
+  tokenBudget: z.number().min(50).max(2e3).optional(),
+  minConfidence: z.number().min(0).max(1).optional(),
+  maxInstructions: z.number().min(1).max(10).optional()
+});
+var compileInstructionsResponse = z.object({
+  instructions: z.array(z.object({
+    patternId: z.string(),
+    instruction: z.string().max(500),
+    confidence: z.number(),
+    priority: z.number(),
+    source: z.enum(["learned", "explicit", "manual"]),
+    patternType: z.string(),
+    activatedBy: z.array(z.string()),
+    recommendationId: z.string().optional(),
+    triggerContext: z.string().optional(),
+    evidenceSummary: z.string().optional(),
+    firstSurfacing: z.boolean().optional()
+  })),
+  summary: z.string().max(1e3),
+  tokenCount: z.number(),
+  patternsEvaluated: z.number(),
+  patternsActivated: z.number(),
+  conflictsResolved: z.array(z.object({
+    winnerId: z.string(),
+    loserId: z.string(),
+    strategy: z.enum(["priority_override"])
+  })),
+  systemState: z.enum(["ok", "cold_start", "pending_only", "no_match"]).optional(),
+  pendingCount: z.number().min(0).optional(),
+  patternsExcluded: z.number().min(0).optional()
+});
+var recommendation = z.object({
+  id: z.string().uuid(),
+  userId: z.string(),
+  triggerContext: z.string().max(500),
+  practice: z.string().max(1e3),
+  evidenceSummary: z.string().max(2e3).optional(),
+  source: z.enum(["explicit", "learned", "manual"]),
+  outcomeSignal: z.enum(["positive", "neutral", "unknown"]),
+  confidence: z.number().min(0).max(1),
+  evidenceMemoryIds: z.array(z.string().uuid()).max(50).optional(),
+  triggerEmbeddingStatus: z.enum(["pending", "complete", "failed"]),
+  applicationCount: z.number().min(0),
+  provisional: z.boolean(),
+  status: z.enum(["pending_review", "active", "paused", "dismissed", "superseded"]),
+  validFrom: z.string().datetime().optional(),
+  validUntil: z.string().datetime().nullable().optional(),
+  supersededBy: z.string().uuid().nullable().optional(),
+  createdAt: z.string().datetime(),
+  updatedAt: z.string().datetime()
+});
+var createRecommendationRequest = z.object({
+  triggerContext: z.string().max(500),
+  practice: z.string().max(1e3),
+  evidenceSummary: z.string().max(2e3).optional(),
+  outcomeSignal: z.enum(["positive", "neutral", "unknown"]).optional(),
+  evidenceMemoryIds: z.array(z.string().uuid()).max(50).optional(),
+  activateImmediately: z.boolean().optional()
+});
+var matchRecommendationsRequest = z.object({
+  content: z.string().max(1e4),
+  limit: z.number().min(1).max(5).optional(),
+  similarityThreshold: z.number().min(0.1).max(0.99).optional()
+});
 var serviceCheck = z.object({
   /** Service status */
   status: z.enum(["up", "down"]),
@@ -5143,32 +6538,44 @@ var searchRequest = z.object({
   memoryType: z.enum(["episodic", "semantic", "procedural"]).optional(),
   /** Filter by conversation ID */
   conversationId: z.string().optional(),
+  /** Task-scoped retrieval: returns own-history first, fills remainder with cross-task results. */
+  taskId: z.string().max(200).optional(),
+  /** Filter by task outcome. Use 'resolved' to find successful approaches from past tasks. */
+  outcomeFilter: z.enum(["resolved", "unresolved", "any"]).optional(),
   /** Include topics associated with matched memories (defaults to false for performance) */
   includeTopics: z.boolean().optional(),
   /** Include entities mentioned in matched memories (defaults to false for performance) */
   includeEntities: z.boolean().optional(),
   /** Include facts extracted from matched memories (defaults to false for performance) */
   includeFacts: z.boolean().optional(),
+  /** Include claims associated with matched memories (defaults to true) */
+  includeClaims: z.boolean().optional(),
   /** Filter entities by type (e.g., PERSON, TECHNOLOGY, PROJECT) */
   entityTypes: z.array(z.string().max(50)).max(20).optional(),
   /** Enable entity graph traversal branch in hybrid search (default false) */
   expandEntities: z.boolean().optional(),
-  /** Enable topic graph traversal branch in hybrid search (default false) */
+  /** Enable topic graph traversal branch in hybrid search (default true) */
   expandTopics: z.boolean().optional(),
-  /** Enable fact graph traversal branch in hybrid search (default false) */
+  /** Enable fact graph traversal branch in hybrid search (default true) */
   expandFacts: z.boolean().optional(),
   /** Include superseded and contradicted memories in results (default false) */
   includeSuperseded: z.boolean().optional(),
-  /** Weight for entity graph branch in hybrid search (0-1, default 0.7) */
+  /** Weight for entity graph branch in hybrid search (0-1, default 0.1) */
   entityWeight: z.number().min(0).max(1).optional(),
   /** Weight for topic graph branch in hybrid search (0-1, default 0.5) */
   topicWeight: z.number().min(0).max(1).optional(),
   /** Weight for fact graph branch in hybrid search (0-1, default 0.6) */
   factWeight: z.number().min(0).max(1).optional(),
+  /** Weight for question graph branch in hybrid search (0-1) */
+  questionWeight: z.number().min(0).max(1).optional(),
+  /** Weight for claims vector branch in hybrid search (0-1, default 0.5) */
+  claimsWeight: z.number().min(0).max(1).optional(),
   /** Field to sort results by (defaults to 'relevance' for search, 'createdAt' for list) */
   sortBy: z.enum(["relevance", "createdAt", "updatedAt", "eventTime"]).optional(),
   /** Sort order: 'asc' or 'desc' (defaults to 'desc' for timestamps, 'desc' for relevance) */
-  order: z.enum(["asc", "desc"]).optional()
+  order: z.enum(["asc", "desc"]).optional(),
+  /** Include facet aggregation (topics, memoryType, effectiveState) in response (defaults to false) */
+  includeFacets: z.boolean().optional()
 });
 var entity = z.object({
   /** Entity name */
@@ -5176,80 +6583,39 @@ var entity = z.object({
   /** Entity type */
   type: z.string().optional()
 });
-var topicReference = z.object({
-  /** Topic unique identifier */
-  id: z.string().uuid(),
-  /** Topic name */
-  name: z.string(),
-  /** When the topic was created */
-  createdAt: z.string().datetime().optional()
-});
 var searchResult = z.lazy(() => z.object({
-  memory: z.object({
-    /** Unique memory identifier */
-    id: z.string(),
-    /** Optional human-readable name for deterministic retrieval. Only the HEAD version carries the name. */
-    name: z.string().regex(/^[a-z0-9][a-z0-9-]{0,62}[a-z0-9]$/).optional(),
-    /** Version number for named memories (1 for first version, increments on update) */
-    version: z.number().min(1).optional(),
-    /** Memory content */
-    content: z.string(),
-    /** Type of memory */
-    memoryType: z.enum(["episodic", "semantic", "procedural"]),
-    /** Context or domain of the memory */
-    context: z.string().optional(),
-    /** Associated topics */
-    topics: z.array(z.string()).optional(),
-    /** System ingestion timestamp (when the system learned about this) */
-    timestamp: z.string().datetime().optional(),
-    /** Event time (when the event actually occurred in reality) */
-    eventTime: z.string().datetime().optional(),
-    /** Validity start time (when this fact becomes valid) */
-    validFrom: z.string().datetime().optional(),
-    /** Validity end time (when this fact expires, null means never expires) */
-    validTo: z.string().datetime().nullable().optional(),
-    /** Creation timestamp */
-    createdAt: z.string().datetime(),
-    /** Last update timestamp */
-    updatedAt: z.string().datetime(),
-    /** Confidence score (0-1) for this memory's accuracy */
-    confidenceScore: z.number().min(0).max(1).optional(),
-    /** Basis for the confidence score */
-    confidenceBasis: z.enum(["direct-statement", "repeated-mention", "single-mention", "hedged", "inference", "external-source", "contradicted"]).optional(),
-    /** Effective state of the memory in the narrative */
-    effectiveState: z.enum(["current", "superseded", "contradicted"]).optional(),
-    /** Status of automatic content extraction */
-    extractionStatus: z.enum(["pending", "completed", "failed", "skipped"]).optional(),
-    /** When extraction was completed */
-    extractionCompletedAt: z.string().datetime().optional(),
-    /** Number of topics extracted from content */
-    extractedTopicCount: z.number().min(0).optional(),
-    /** Number of facts extracted from content */
-    extractedFactCount: z.number().min(0).optional(),
-    /** Number of entities extracted from content */
-    extractedEntityCount: z.number().min(0).optional(),
-    /** Topics explicitly provided by the user */
-    userTopics: z.array(z.string()).optional(),
-    /** Topics automatically extracted from content */
-    extractedTopics: z.array(z.string()).optional(),
-    /** Agent session ID that created this memory (MCP session ID or CLI session UUID). Used to group memories by agent instance for conversation threading. */
-    agentSessionId: z.string().nullable().optional(),
-    /** Entities extracted from memory content */
-    entities: z.array(z.object({
-      /** Entity name */
-      name: z.string(),
-      /** Entity type */
-      type: z.string(),
-      /** Extraction confidence */
-      confidence: z.number().min(0).max(1).optional()
-    })).optional()
-  }),
-  /** Relevance score for this result */
-  score: z.number(),
+  /** Unique memory identifier */
+  id: z.string(),
+  /** Full memory content */
+  content: z.string(),
+  /** Truncated content preview (max 200 chars) */
+  preview: z.string(),
+  /** Optional human-readable name for deterministic retrieval */
+  name: z.string().nullable().optional(),
+  /** Type of memory */
+  memoryType: z.enum(["episodic", "semantic", "procedural"]),
+  /** Associated topics */
+  topics: z.array(z.string()).optional(),
+  /** Conversation this memory belongs to */
+  conversationId: z.string().nullable().optional(),
+  /** System ingestion timestamp */
+  timestamp: z.string().datetime().optional(),
+  /** Event time (when the event actually occurred) */
+  eventTime: z.string().datetime().optional(),
+  /** Validity start time */
+  validFrom: z.string().datetime().optional(),
+  /** Creation timestamp */
+  createdAt: z.string().datetime().optional(),
+  /** Last update timestamp */
+  updatedAt: z.string().datetime().optional(),
+  /** Effective state of the memory */
+  effectiveState: z.string().optional(),
+  /** Confidence score (0-1) */
+  confidenceScore: z.number().min(0).max(1).optional(),
+  /** Overall relevance score for this result */
+  score: z.number().nullable().optional(),
   /** Entities mentioned in this memory */
   entities: z.array(entity).optional(),
-  /** Topics associated with this memory */
-  topics: z.array(topicReference).optional(),
   /** Facts extracted from this memory */
   facts: z.array(z.object({
     /** Fact subject */
@@ -5261,10 +6627,8 @@ var searchResult = z.lazy(() => z.object({
     /** Confidence */
     confidence: z.number().min(0).max(1).optional()
   })).optional(),
-  /** Search method used to find this result */
-  searchMethod: z.string().optional(),
   /** Combined RRF score for hybrid search */
-  hybridScore: z.number().optional(),
+  hybridScore: z.number().nullable().optional(),
   /** Vector similarity score (0-1) */
   vectorScore: z.number().optional(),
   /** Rank in vector search results */
@@ -5310,22 +6674,80 @@ var temporalMetadata = z.object({
   includeExpired: z.boolean(),
   /** Whether temporal fields are included in results */
   temporalFieldsIncluded: z.boolean()
-}).nullable();
+});
+var searchMeta = z.lazy(() => z.object({
+  /** Total number of results matching the query */
+  total: z.number(),
+  /** Current page number (1-based) */
+  page: z.number(),
+  /** Number of results per page */
+  pageSize: z.number(),
+  /** Search duration in milliseconds */
+  searchTime: z.number(),
+  /** Search method used for this query */
+  searchMethod: z.string(),
+  /** Temporal query metadata (present when temporal filters are used) */
+  temporalMetadata: temporalMetadata.optional()
+}));
+var facetEntry = z.object({
+  /** Facet value */
+  value: z.string(),
+  /** Number of results with this value */
+  count: z.number()
+});
+var facets = z.lazy(() => z.object({
+  /** Topic facet counts (top 20 by frequency) */
+  topics: z.array(facetEntry),
+  /** Memory type facet counts */
+  memoryType: z.array(facetEntry),
+  /** Effective state facet counts */
+  effectiveState: z.array(facetEntry)
+}));
+var claimGroupClaim = z.object({
+  /** Claim ID */
+  id: z.string(),
+  /** Claim content text */
+  content: z.string(),
+  /** Memory this claim was extracted from */
+  memoryId: z.string(),
+  /** Claim creation timestamp */
+  createdAt: z.string(),
+  /** When the claimed event occurred */
+  occurredStart: z.string().optional()
+});
+var claimGroupSignals = z.object({
+  /** Number of claims in this group */
+  n_claims: z.number(),
+  /** Minimum LLM-judged alignment score among all pairs in the group (0=conflict, 1=corroborate) */
+  alignment_min: z.number(),
+  /** Days between earliest and latest claim in the group */
+  temporal_spread_days: z.number(),
+  /** True if alignment_min < 0.85, indicating potential conflict */
+  has_low_alignment_pair: z.boolean(),
+  /** True if alignment_min < 0.4 — claims directly conflict or one supersedes the other */
+  has_conflict: z.boolean(),
+  /** True if temporal_spread_days > 30 */
+  has_temporal_spread: z.boolean()
+});
+var claimGroup = z.lazy(() => z.object({
+  /** Deterministic group ID */
+  id: z.string(),
+  /** Claims in this group, sorted by createdAt descending (newest first) */
+  claims: z.array(claimGroupClaim),
+  /** Computed signals about the claim cluster */
+  signals: claimGroupSignals
+}));
 var searchResponse = z.lazy(() => z.object({
-  /** Search results with metadata */
+  /** Flattened search results with memory fields and search metadata */
   data: z.array(searchResult),
-  /** Search method used for this query */
-  searchMethod: z.string().optional(),
-  pagination: z.object({
-    /** Maximum number of items per page */
-    limit: z.number().min(1),
-    /** Number of items to skip */
-    offset: z.number().min(0),
-    /** Total number of items */
-    count: z.number().min(0)
-  }),
-  /** Temporal query metadata (null for semantic/hybrid search) */
-  temporalMetadata
+  /** Search metadata including pagination, timing, and method */
+  meta: searchMeta,
+  /** Facet aggregations (only present when includeFacets=true) */
+  facets: facets.optional(),
+  /** Reader instructions for interpreting claims and resolving conflicts */
+  instructions: z.string().optional(),
+  /** Clusters of related claims that may conflict. Only present when relevant groups exist. Claims within each group are sorted newest-first. */
+  claim_groups: z.array(claimGroup).optional()
 }));
 var fact = z.object({
   /** Unique identifier for the fact */
@@ -5402,8 +6824,8 @@ var entityNode = z.object({
   name: z.string(),
   /** Normalized (lowercase) name for deduplication */
   normalizedName: z.string(),
-  /** Entity type classification */
-  type: z.enum(["PERSON", "PROJECT", "TECHNOLOGY", "COMPONENT", "API_ENDPOINT", "FILE", "CONCEPT", "ORGANIZATION", "LOCATION"]),
+  /** Entity type classification (v2: PERSON, ORGANIZATION, CONCEPT; legacy types accepted) */
+  type: z.enum(["PERSON", "ORGANIZATION", "CONCEPT", "PROJECT", "TECHNOLOGY", "COMPONENT", "API_ENDPOINT", "FILE", "LOCATION"]),
   /** Alternative names for this entity */
   aliases: z.array(z.string()).optional(),
   /** Extraction confidence score (0-1) */
@@ -5479,11 +6901,11 @@ var memoryRelationship = z.object({
   /** ID of the target memory (the memory being related to) */
   targetMemoryId: z.string(),
   /** Type of relationship between memories */
-  type: z.enum(["SUPERSEDES", "FOLLOWS", "RESOLVES", "CONTRADICTS", "REFERENCES"]),
+  type: z.enum(["SUPERSEDES", "FOLLOWS", "RESOLVES", "CONTRADICTS", "REFERENCES", "DUPLICATES"]),
   /** Confidence score for the relationship (0-1) */
   confidence: z.number().min(0).max(1),
   /** How the relationship was created */
-  creationMethod: z.enum(["manual", "auto-semantic", "auto-temporal"]),
+  creationMethod: z.enum(["manual", "auto-semantic", "auto-temporal", "auto-llm"]),
   /** Human-readable explanation for why this relationship exists */
   reason: z.string().optional(),
   /** When the relationship was created */
@@ -5493,7 +6915,7 @@ var createMemoryRelationshipRequest = z.object({
   /** ID of the target memory to create a relationship with */
   targetMemoryId: z.string().min(1),
   /** Type of relationship between memories */
-  type: z.enum(["SUPERSEDES", "FOLLOWS", "RESOLVES", "CONTRADICTS", "REFERENCES"]),
+  type: z.enum(["SUPERSEDES", "FOLLOWS", "RESOLVES", "CONTRADICTS", "REFERENCES", "DUPLICATES"]),
   /** Confidence score for the relationship (0-1, defaults to 1.0 for manual) */
   confidence: z.number().min(0).max(1).optional(),
   /** Optional explanation for the relationship */
@@ -5554,7 +6976,7 @@ var addMemoryToNarrativeRequest = z.object({
   /** Position in the narrative (0-indexed, omit for append) */
   position: z.number().min(0).optional()
 });
-var narrativeMemory = z.object({
+var narrativeMemory = z.lazy(() => z.object({
   memory: z.object({
     /** Unique memory identifier */
     id: z.string(),
@@ -5578,6 +7000,8 @@ var narrativeMemory = z.object({
     validFrom: z.string().datetime().optional(),
     /** Validity end time (when this fact expires, null means never expires) */
     validTo: z.string().datetime().nullable().optional(),
+    /** Environment context for memory scoping — product, service, team, component, role. */
+    codeContext: codeContext.optional(),
     /** Creation timestamp */
     createdAt: z.string().datetime(),
     /** Last update timestamp */
@@ -5587,23 +7011,57 @@ var narrativeMemory = z.object({
     /** Basis for the confidence score */
     confidenceBasis: z.enum(["direct-statement", "repeated-mention", "single-mention", "hedged", "inference", "external-source", "contradicted"]).optional(),
     /** Effective state of the memory in the narrative */
-    effectiveState: z.enum(["current", "superseded", "contradicted"]).optional(),
-    /** Status of automatic content extraction */
-    extractionStatus: z.enum(["pending", "completed", "failed", "skipped"]).optional(),
+    effectiveState: z.enum(["current", "superseded", "contradicted", "duplicate"]).optional(),
+    /** Authority level: directive (mandates) > decision (choices with reasoning) > observation (learned during work) > auto-captured (generated content) */
+    authority: z.enum(["directive", "decision", "observation", "auto-captured"]).optional(),
+    /** Legacy aggregate extraction status. DERIVED on read from the six per-stage statuses (contentEmbeddingStatus, summaryStatus, questionsStatus, summaryEmbeddingStatus, questionsEmbeddingStatus, graphStatus). Preserved for SDK compatibility per PRD memory-creation-pipeline-v2 §5 Q7. */
+    extractionStatus: z.enum(["pending", "queued", "running", "completed", "failed", "skipped"]).optional(),
     /** When extraction was completed */
     extractionCompletedAt: z.string().datetime().optional(),
+    /** Pipeline 2 content-embedding stage status. Tracks the queue lifecycle for writing m.embedding (primary content embedding). */
+    contentEmbeddingStatus: z.enum(["pending", "queued", "running", "completed", "failed", "skipped"]).optional(),
+    /** AI-generated summary of the memory content */
+    summary: z.string().optional(),
+    /** Pipeline 1 summary stage status. Tracks generation of m.summary by the summary-qna LLM call. */
+    summaryStatus: z.enum(["pending", "queued", "running", "completed", "failed", "skipped"]).optional(),
+    /** Pipeline 1 questions stage status. Tracks generation of anticipated Question nodes by the summary-qna LLM call. */
+    questionsStatus: z.enum(["pending", "queued", "running", "completed", "failed", "skipped"]).optional(),
+    /** Pipeline 2 summary-embedding stage status. Tracks the queue lifecycle for writing m.summaryEmbedding (depends on summaryStatus=completed). */
+    summaryEmbeddingStatus: z.enum(["pending", "queued", "running", "completed", "failed", "skipped"]).optional(),
+    /** Pipeline 2 question-embedding stage status. Tracks the queue lifecycle for writing Question.embedding for each anticipated question (depends on questionsStatus=completed). */
+    questionsEmbeddingStatus: z.enum(["pending", "queued", "running", "completed", "failed", "skipped"]).optional(),
+    /** Pipeline 3 graph-extraction stage status. Tracks generation of entities, facts, topics, authority, and memory-type. Replaces the role formerly played by the monolithic extractionStatus writer. */
+    graphStatus: z.enum(["pending", "queued", "running", "completed", "failed", "skipped"]).optional(),
+    /** When graphStatus=skipped, records why graph extraction was skipped. Mirrors the legacy extractionSkipReason field but scoped to the graph pipeline. */
+    graphSkipReason: z.enum(["global_disabled", "plan_excluded", "user_opt_out", "content_too_short", "legacy", "budget_exhausted"]).nullable().optional(),
+    /** When extractionStatus=skipped, records why extraction was skipped. global_disabled = GRAPH_EXTRACTION_ENABLED=false kill switch. */
+    extractionSkipReason: z.enum(["global_disabled", "plan_excluded", "user_opt_out", "content_too_short", "legacy"]).optional(),
+    /** Status of primary (Ollama) embedding generation via durable queue */
+    embeddingStatus: z.enum(["queued", "running", "completed", "failed", "skipped"]).optional(),
+    /** Status of secondary (OpenAI) dual-write embedding generation via durable queue */
+    embeddingOpenaiStatus: z.enum(["queued", "running", "completed", "failed", "skipped"]).optional(),
+    /** True if the primary content embedding used a head-truncated input (model context exceeded). */
+    embeddingTruncated: z.boolean().optional(),
+    /** Token count of the original content (pre-truncation, cl100k proxy). Useful for identifying under-indexed memories. */
+    embeddingOriginalTokens: z.number().min(0).optional(),
+    /** Smart-field strategy used to produce the primary content embedding. */
+    embeddingStrategy: z.enum(["full", "head-truncated", "summary-selected", "question-selected"]).optional(),
     /** Number of topics extracted from content */
     extractedTopicCount: z.number().min(0).optional(),
     /** Number of facts extracted from content */
     extractedFactCount: z.number().min(0).optional(),
     /** Number of entities extracted from content */
     extractedEntityCount: z.number().min(0).optional(),
+    /** Number of memories this memory contradicts via outgoing CONTRADICTS relationships */
+    conflictCount: z.number().min(0).optional(),
+    /** Memory visibility level. Null/undefined treated as 'private' for backward compatibility. 'admin_visible' is computed at retrieval time when an org owner/admin queries another member's post-join memory and is never accepted on writes. */
+    visibility: z.enum(["private", "shared_with_users", "shared_with_org", "admin_visible"]).optional(),
+    /** User IDs this memory is shared with (only populated when visibility = 'shared_with_users') */
+    sharedWith: z.array(z.string()).optional(),
     /** Topics explicitly provided by the user */
     userTopics: z.array(z.string()).optional(),
     /** Topics automatically extracted from content */
     extractedTopics: z.array(z.string()).optional(),
-    /** Agent session ID that created this memory (MCP session ID or CLI session UUID). Used to group memories by agent instance for conversation threading. */
-    agentSessionId: z.string().nullable().optional(),
     /** Entities extracted from memory content */
     entities: z.array(z.object({
       /** Entity name */
@@ -5612,13 +7070,27 @@ var narrativeMemory = z.object({
       type: z.string(),
       /** Extraction confidence */
       confidence: z.number().min(0).max(1).optional()
-    })).optional()
+    })).optional(),
+    /** Task identifier for agentic loop memories */
+    taskId: z.string().nullable().optional(),
+    /** Task outcome status */
+    outcome: z.enum(["resolved", "unresolved"]).nullable().optional(),
+    /** Attempt number within the task */
+    attemptNumber: z.number().nullable().optional(),
+    /** Distillation pipeline stage status */
+    distillStatus: z.enum(["pending", "queued", "running", "completed", "failed", "skipped"]).nullable().optional(),
+    /** Reason distillation was skipped */
+    distillSkipReason: z.enum(["global_disabled", "plan_excluded", "user_opt_out", "content_too_short", "legacy", "budget_exhausted"]).nullable().optional(),
+    /** Error message if distillation failed */
+    distillError: z.string().nullable().optional(),
+    /** ISO 8601 timestamp when distillation completed */
+    distillCompletedAt: z.string().nullable().optional()
   }),
   /** Position of this memory in the narrative (0-indexed) */
   position: z.number().min(0),
   /** Effective state of this memory in the narrative context */
   effectiveState: z.enum(["current", "superseded", "contradicted"]).optional()
-});
+}));
 var narrativeTimelineResponse = z.lazy(() => z.object({
   data: z.array(narrativeMemory),
   narrative: narrativeThread,
@@ -5805,7 +7277,7 @@ var listPaymentMethodsResponse = z.lazy(() => z.object({
 }));
 var digestRequest = z.object({
   /** The topic or subject to generate a digest for */
-  query: z.string().min(1),
+  query: z.string().min(1).max(2e3),
   /** Time window filter (e.g., "7d", "24h", "2w", "30m"). Only considers memories within this window. */
   recent: z.string().optional(),
   /** Filter to memories with these topics */
@@ -5817,7 +7289,9 @@ var digestRequest = z.object({
   /** Maximum number of memories to consider (1-500, default 100) */
   maxSources: z.number().min(1).max(500).optional(),
   /** Whether to include source memory IDs in the response */
-  includeMemoryIds: z.boolean().optional()
+  includeMemoryIds: z.boolean().optional(),
+  /** Number of most-recent matching memories to return VERBATIM (full stored content, untouched) in `recentMemories`, instead of synthesizing them into `digest`. The remaining (older) memories are still synthesized into `digest` as usual. Recency is determined by event time when present, else system timestamp, else creation time. Default 0 = current behavior (synthesize all memories, `recentMemories` empty). When the total matched count is <= verbatimRecent, all matches are returned in `recentMemories` and `digest` is an empty string (no older memories to synthesize). Range 0-50. */
+  verbatimRecent: z.number().min(0).max(50).optional()
 });
 var digestTimeRange = z.object({
   /** Earliest memory timestamp in the digest sources */
@@ -5838,6 +7312,12 @@ var digestMetadata = z.lazy(() => z.object({
   timeRange: digestTimeRange,
   /** Output format used for this digest */
   format: z.enum(["structured", "narrative", "timeline", "status-report"]),
+  /** Average relevance score (0-1) of the source memories used in synthesis. Low values (<0.02) indicate the query may not have strong matches. */
+  averageRelevance: z.number().min(0).max(1).optional(),
+  /** True when averageRelevance falls in the narrow-window band (>= DIGEST_RELEVANCE_THRESHOLD but < NARROW_WINDOW_FALLBACK_CEILING) — the digest synthesised from weak matches that may not represent strong context. Consumers should surface a warning to the calling agent. */
+  narrowWindowFallback: z.boolean().optional(),
+  /** True when the digest is in the narrow-window band AND the source memories span 2+ distinct codeContext.product values (or none share a product). Indicates the synthesis is drawn from heterogeneous, possibly cross-project sources — likely the wrong project for the calling agent. See support#183. */
+  crossProjectFallback: z.boolean().optional(),
   /** ISO 8601 timestamp when the digest was generated */
   generatedAt: z.string().datetime(),
   /** Recursion stats (only present when recursive synthesis is used) */
@@ -5891,6 +7371,8 @@ var digestResponse = z.lazy(() => z.object({
   metadata: digestMetadata,
   /** Source memories used to generate the digest, for traceability */
   sources: z.array(digestSource),
+  /** The N most-recent matching memories returned VERBATIM (full stored content, untouched), where N = the request's verbatimRecent. Ordered newest-first. Empty/omitted when verbatimRecent is 0 (the default). These memories are NOT synthesized into `digest` — the synthesis covers only the older remainder. Lets callers preserve the exact structure of recent items (per-item status, identifiers, next-step) while still condensing the older tail. */
+  recentMemories: z.array(memory).optional(),
   /** Top extracted facts relevant to the digest, deduplicated and ranked by frequency */
   keyFacts: z.array(digestKeyFact).optional(),
   /** Key entities mentioned across source memories */
@@ -5898,6 +7380,84 @@ var digestResponse = z.lazy(() => z.object({
   /** Breakdown of source memories by effective state (current/superseded/contradicted) */
   effectiveStateBreakdown: effectiveStateBreakdown.optional()
 }));
+var exportRequest = z.object({
+  /** Optional search query to filter memories for export */
+  query: z.string().max(2e3).optional(),
+  /** Filter by topics */
+  topics: z.array(z.string().max(100)).max(50).optional(),
+  /** Filter by memory type */
+  memoryType: z.enum(["episodic", "semantic", "procedural"]).optional(),
+  /** Export format: json or csv (default: json) */
+  format: z.enum(["json", "csv"]).optional(),
+  /** Optional field selection. If omitted, all standard fields are included. */
+  fields: z.array(z.string().max(50)).max(20).optional(),
+  /** Maximum results to export (default 100, max 1000) */
+  limit: z.number().min(1).max(1e3).optional()
+});
+var bulkUpdateRequest = z.object({
+  /** Memory IDs to update (max 100) */
+  ids: z.array(z.string().min(1)).min(1).max(100),
+  /** Fields to update on all specified memories */
+  updates: z.object({
+    /** Replace topics on all specified memories */
+    topics: z.array(z.string().max(100)).max(50).optional(),
+    /** Set memory type on all specified memories */
+    memoryType: z.enum(["episodic", "semantic", "procedural"]).optional()
+  })
+});
+var bulkUpdateResponse = z.object({
+  /** Number of memories successfully updated */
+  updated: z.number(),
+  /** Number of memories that failed to update */
+  failed: z.number(),
+  /** Per-item error details */
+  errors: z.array(z.object({
+    /** Memory ID that failed */
+    id: z.string(),
+    /** Error message */
+    error: z.string()
+  }))
+});
+var bulkDeleteRequest = z.object({
+  /** Memory IDs to delete (max 100) */
+  ids: z.array(z.string().min(1)).min(1).max(100),
+  /** Must be true to confirm bulk deletion */
+  confirmDeletion: z.literal(true)
+});
+var bulkDeleteResponse = z.object({
+  /** Number of memories successfully deleted */
+  deleted: z.number(),
+  /** Number of memories that failed to delete */
+  failed: z.number(),
+  /** Per-item error details */
+  errors: z.array(z.object({
+    /** Memory ID that failed */
+    id: z.string(),
+    /** Error message */
+    error: z.string()
+  }))
+});
+var bulkTagRequest = z.object({
+  /** Memory IDs to modify tags on (max 100) */
+  ids: z.array(z.string().min(1)).min(1).max(100),
+  /** Topics to add to all specified memories */
+  addTopics: z.array(z.string().max(100)).max(50).optional(),
+  /** Topics to remove from all specified memories */
+  removeTopics: z.array(z.string().max(100)).max(50).optional()
+});
+var bulkTagResponse = z.object({
+  /** Number of memories successfully modified */
+  modified: z.number(),
+  /** Number of memories that failed to modify */
+  failed: z.number(),
+  /** Per-item error details */
+  errors: z.array(z.object({
+    /** Memory ID that failed */
+    id: z.string(),
+    /** Error message */
+    error: z.string()
+  }))
+});
 var buildContextRequest = z.object({
   /** What you are about to work on */
   context: z.string().min(1).max(2e3),
@@ -5963,7 +7523,9 @@ var buildContextMeta = z.object({
   /** Search terms extracted from the context and files */
   contextTerms: z.array(z.string()),
   /** Hours window used for recent activity */
-  recentHours: z.number()
+  recentHours: z.number(),
+  /** Sections whose backing query exceeded the per-branch timeout and were returned empty. Present only when at least one branch timed out, so an empty section can otherwise be read as 'no data'. */
+  timedOutSections: z.array(z.string()).optional()
 });
 var buildContextResponse = z.lazy(() => z.object({
   /** Most relevant active conversation, or null if none found */
@@ -5979,6 +7541,39 @@ var buildContextResponse = z.lazy(() => z.object({
   /** Request metadata for transparency */
   meta: buildContextMeta
 }));
+var systemAlert = z.object({
+  id: z.string().uuid(),
+  title: z.string().min(1).max(120),
+  body: z.string().min(1).max(2e3),
+  severity: z.enum(["info", "warning", "critical"]),
+  active: z.boolean().optional(),
+  dismissible: z.boolean().optional(),
+  targetAllUsers: z.boolean().optional(),
+  targetUserIds: z.array(z.string()).optional(),
+  createdAt: z.string().datetime(),
+  expiresAt: z.string().datetime().nullable(),
+  createdBy: z.string()
+});
+var createSystemAlertRequest = z.object({
+  title: z.string().min(1).max(120),
+  body: z.string().min(1).max(2e3),
+  severity: z.enum(["info", "warning", "critical"]).optional(),
+  active: z.boolean().optional(),
+  dismissible: z.boolean().optional(),
+  targetAllUsers: z.boolean().optional(),
+  targetUserIds: z.array(z.string().uuid()).max(1e3).optional(),
+  expiresAt: z.string().datetime().nullable().optional()
+});
+var updateSystemAlertRequest = z.object({
+  title: z.string().min(1).max(120).optional(),
+  body: z.string().min(1).max(2e3).optional(),
+  severity: z.enum(["info", "warning", "critical"]).optional(),
+  active: z.boolean().optional(),
+  dismissible: z.boolean().optional(),
+  targetAllUsers: z.boolean().optional(),
+  targetUserIds: z.array(z.string().uuid()).max(1e3).optional(),
+  expiresAt: z.string().datetime().nullable().optional()
+});
 
 // src/index.ts
 var Memnexus = class {
@@ -5993,6 +7588,8 @@ var Memnexus = class {
   patterns;
   /** Behavioral pattern tracking and state management endpoints operations */
   behavior;
+  /** Behavioral recommendation management endpoints (v2) operations */
+  recommendations;
   /** Narrative thread management endpoints operations */
   narratives;
   /** Observability and metrics endpoints for production monitoring operations */
@@ -6017,8 +7614,14 @@ var Memnexus = class {
   artifacts;
   /** API key management endpoints operations */
   apiKeys;
+  /** System alerts banner endpoints (customer portal) operations */
+  alerts;
   /** Admin management endpoints for invite codes and platform configuration operations */
   admin;
+  /** Admin endpoints for managing system alerts operations */
+  adminAlerts;
+  /** Admin Pipeline operations */
+  adminPipeline;
   /**
    * Create a new SDK client.
    * @param config - SDK configuration
@@ -6033,6 +7636,7 @@ var Memnexus = class {
     this.system = new SystemService(this.config);
     this.patterns = new PatternsService(this.config);
     this.behavior = new BehaviorService(this.config);
+    this.recommendations = new RecommendationsService(this.config);
     this.narratives = new NarrativesService(this.config);
     this.monitoring = new MonitoringService(this.config);
     this.memories = new MemoriesService(this.config);
@@ -6045,7 +7649,10 @@ var Memnexus = class {
     this.billing = new BillingService(this.config);
     this.artifacts = new ArtifactsService(this.config);
     this.apiKeys = new ApiKeysService(this.config);
+    this.alerts = new AlertsService(this.config);
     this.admin = new AdminService(this.config);
+    this.adminAlerts = new AdminAlertsService(this.config);
+    this.adminPipeline = new AdminPipelineService(this.config);
   }
   /**
    * Set the API token for authentication.
@@ -6058,6 +7665,7 @@ var Memnexus = class {
     this.system.token = token;
     this.patterns.token = token;
     this.behavior.token = token;
+    this.recommendations.token = token;
     this.narratives.token = token;
     this.monitoring.token = token;
     this.memories.token = token;
@@ -6070,7 +7678,10 @@ var Memnexus = class {
     this.billing.token = token;
     this.artifacts.token = token;
     this.apiKeys.token = token;
+    this.alerts.token = token;
     this.admin.token = token;
+    this.adminAlerts.token = token;
+    this.adminPipeline.token = token;
   }
   /**
    * Set the base URL for API requests.
@@ -6083,6 +7694,7 @@ var Memnexus = class {
     this.system.baseUrl = baseUrl;
     this.patterns.baseUrl = baseUrl;
     this.behavior.baseUrl = baseUrl;
+    this.recommendations.baseUrl = baseUrl;
     this.narratives.baseUrl = baseUrl;
     this.monitoring.baseUrl = baseUrl;
     this.memories.baseUrl = baseUrl;
@@ -6095,7 +7707,10 @@ var Memnexus = class {
     this.billing.baseUrl = baseUrl;
     this.artifacts.baseUrl = baseUrl;
     this.apiKeys.baseUrl = baseUrl;
+    this.alerts.baseUrl = baseUrl;
     this.admin.baseUrl = baseUrl;
+    this.adminAlerts.baseUrl = baseUrl;
+    this.adminPipeline.baseUrl = baseUrl;
   }
   /**
    * Set the environment.
@@ -6108,6 +7723,7 @@ var Memnexus = class {
     this.system.environment = environment;
     this.patterns.environment = environment;
     this.behavior.environment = environment;
+    this.recommendations.environment = environment;
     this.narratives.environment = environment;
     this.monitoring.environment = environment;
     this.memories.environment = environment;
@@ -6120,12 +7736,18 @@ var Memnexus = class {
     this.billing.environment = environment;
     this.artifacts.environment = environment;
     this.apiKeys.environment = environment;
+    this.alerts.environment = environment;
     this.admin.environment = environment;
+    this.adminAlerts.environment = environment;
+    this.adminPipeline.environment = environment;
   }
 };
 var index_default = Memnexus;
 export {
+  AdminAlertsService,
+  AdminPipelineService,
   AdminService,
+  AlertsService,
   ApiKeysService,
   ArtifactsService,
   BehaviorService,
@@ -6143,6 +7765,7 @@ export {
   MonitoringService,
   NarrativesService,
   PatternsService,
+  RecommendationsService,
   SdkError,
   SerializationStyle,
   SystemService,
@@ -6163,8 +7786,20 @@ export {
   buildContextPattern,
   buildContextRequest,
   buildContextResponse,
+  bulkDeleteRequest,
+  bulkDeleteResponse,
+  bulkTagRequest,
+  bulkTagResponse,
+  bulkUpdateRequest,
+  bulkUpdateResponse,
   checkoutSessionResponse,
+  claimGroup,
+  claimGroupClaim,
+  claimGroupSignals,
+  codeContext,
   community,
+  compileInstructionsRequest,
+  compileInstructionsResponse,
   conversation,
   createArtifactRequest,
   createCheckoutSessionRequest,
@@ -6176,6 +7811,8 @@ export {
   createMemoryResponseMeta,
   createNarrativeRequest,
   createPortalSessionRequest,
+  createRecommendationRequest,
+  createSystemAlertRequest,
   index_default as default,
   digestEntity,
   digestKeyFact,
@@ -6188,6 +7825,9 @@ export {
   entity,
   entityNode,
   error,
+  exportRequest,
+  facetEntry,
+  facets,
   fact,
   factSearchRequest,
   getMemoryResponse,
@@ -6199,6 +7839,7 @@ export {
   listInvoicesResponse,
   listNarrativesResponse,
   listPaymentMethodsResponse,
+  matchRecommendationsRequest,
   memory,
   memoryRelationship,
   memoryRelationshipsResponse,
@@ -6210,20 +7851,24 @@ export {
   pattern,
   paymentMethod,
   portalSessionResponse,
+  precomputedMemoryFields,
+  recommendation,
   relatedMemoryResult,
+  searchMeta,
   searchRequest,
   searchResponse,
   searchResult,
   serviceCheck,
   subscription,
+  systemAlert,
   temporalMetadata,
   topic,
-  topicReference,
   updateArtifactRequest,
   updateFactRequest,
   updateMemoryRequest,
   updateNamedMemoryRequest,
   updateNarrativeRequest,
+  updateSystemAlertRequest,
   user,
   userUsage
 };