@prmichaelsen/remember-mcp 2.2.1 → 2.3.1

package/dist/server.js

@@ -13,6 +13,9 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
     return require.apply(this, arguments);
   throw Error('Dynamic require of "' + x + '" is not supported');
 });
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
 var __commonJS = (cb, mod) => function __require2() {
   return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
 };
@@ -391,6 +394,15 @@ var require_main = __commonJS({
   }
 });
 
+// src/types/space-memory.ts
+var SUPPORTED_SPACES;
+var init_space_memory = __esm({
+  "src/types/space-memory.ts"() {
+    "use strict";
+    SUPPORTED_SPACES = ["the_void"];
+  }
+});
+
 // src/server.ts
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
@@ -503,6 +515,9 @@ function sanitizeUserId(userId) {
   }
   return sanitized.charAt(0).toUpperCase() + sanitized.slice(1);
 }
+function getMemoryCollectionName(userId) {
+  return `Memory_${sanitizeUserId(userId)}`;
+}
 
 // src/firestore/init.ts
 import { initializeApp } from "@prmichaelsen/firebase-admin-sdk-v8";
@@ -542,8 +557,8 @@ async function testFirestoreConnection() {
     if (!initialized) {
       throw new Error("Firestore not initialized");
     }
-    const { getDocument: getDocument2 } = await import("@prmichaelsen/firebase-admin-sdk-v8");
-    await getDocument2("_health_check", "test");
+    const { getDocument: getDocument3 } = await import("@prmichaelsen/firebase-admin-sdk-v8");
+    await getDocument3("_health_check", "test");
     console.log("[Firestore] Connection successful");
     return true;
   } catch (error) {
@@ -1238,6 +1253,13 @@ var createMemoryTool = {
   Each memory has a weight (significance 0-1) and trust level (access control 0-1).
   Location and context are automatically captured from the request.
   
+  **IMPORTANT - Content vs Summary**:
+  - **content**: MUST be EXACT user-provided text. DO NOT paraphrase or modify.
+  - **summary**: Use for AI-generated summaries or interpretations.
+  - Example: User says "Remember: Meeting at 3pm tomorrow"
+    \u2192 content: "Meeting at 3pm tomorrow" (EXACT)
+    \u2192 summary: "User has meeting on 2026-02-17 at 15:00" (AI interpretation)
+  
   Examples:
   - "Remember that I met Sarah at the conference"
   - "Save this recipe for chocolate chip cookies"
@@ -3247,6 +3269,962 @@ async function handleGetPreferences(args, userId) {
   }
 }
 
+// src/services/confirmation-token.service.ts
+import { randomUUID } from "crypto";
+var ConfirmationTokenService = class {
+  EXPIRY_MINUTES = 5;
+  /**
+   * Create a new confirmation request
+   * 
+   * @param userId - User ID who initiated the request
+   * @param action - Action type (e.g., 'publish_memory')
+   * @param payload - Data to store with the request
+   * @param targetCollection - Optional target collection (e.g., 'the_void')
+   * @returns Request ID and token
+   */
+  async createRequest(userId, action, payload, targetCollection) {
+    const token = randomUUID();
+    const now = /* @__PURE__ */ new Date();
+    const expiresAt = new Date(now.getTime() + this.EXPIRY_MINUTES * 60 * 1e3);
+    const request = {
+      user_id: userId,
+      token,
+      action,
+      target_collection: targetCollection,
+      payload,
+      created_at: now.toISOString(),
+      expires_at: expiresAt.toISOString(),
+      status: "pending"
+    };
+    const collectionPath = `users/${userId}/requests`;
+    console.log("[ConfirmationTokenService] Creating request:", {
+      userId,
+      action,
+      targetCollection,
+      collectionPath
+    });
+    const docRef = await addDocument(collectionPath, request);
+    console.log("[ConfirmationTokenService] Request created:", {
+      requestId: docRef.id,
+      token,
+      expiresAt: request.expires_at
+    });
+    return { requestId: docRef.id, token };
+  }
+  /**
+   * Validate and retrieve a confirmation request
+   * 
+   * @param userId - User ID
+   * @param token - Confirmation token
+   * @returns Request with request_id if valid, null otherwise
+   */
+  async validateToken(userId, token) {
+    const collectionPath = `users/${userId}/requests`;
+    console.log("[ConfirmationTokenService] Validating token:", {
+      userId,
+      token,
+      collectionPath
+    });
+    const queryOptions = {
+      where: [
+        { field: "token", op: "==", value: token },
+        { field: "status", op: "==", value: "pending" }
+      ],
+      limit: 1
+    };
+    const results = await queryDocuments(collectionPath, queryOptions);
+    console.log("[ConfirmationTokenService] Query results:", {
+      resultsFound: results.length,
+      hasResults: results.length > 0
+    });
+    if (results.length === 0) {
+      console.log("[ConfirmationTokenService] Token not found or not pending");
+      return null;
+    }
+    const doc = results[0];
+    const request = doc.data;
+    console.log("[ConfirmationTokenService] Request found:", {
+      requestId: doc.id,
+      action: request.action,
+      status: request.status,
+      expiresAt: request.expires_at
+    });
+    const expiresAt = new Date(request.expires_at);
+    if (expiresAt.getTime() < Date.now()) {
+      console.log("[ConfirmationTokenService] Token expired");
+      await this.updateStatus(userId, doc.id, "expired");
+      return null;
+    }
+    return {
+      ...request,
+      request_id: doc.id
+    };
+  }
+  /**
+   * Confirm a request
+   * 
+   * @param userId - User ID
+   * @param token - Confirmation token
+   * @returns Confirmed request if valid, null otherwise
+   */
+  async confirmRequest(userId, token) {
+    const request = await this.validateToken(userId, token);
+    if (!request) {
+      return null;
+    }
+    await this.updateStatus(userId, request.request_id, "confirmed");
+    return {
+      ...request,
+      status: "confirmed",
+      confirmed_at: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  /**
+   * Deny a request
+   * 
+   * @param userId - User ID
+   * @param token - Confirmation token
+   * @returns True if denied successfully, false otherwise
+   */
+  async denyRequest(userId, token) {
+    const request = await this.validateToken(userId, token);
+    if (!request) {
+      return false;
+    }
+    await this.updateStatus(userId, request.request_id, "denied");
+    return true;
+  }
+  /**
+   * Retract a request
+   * 
+   * @param userId - User ID
+   * @param token - Confirmation token
+   * @returns True if retracted successfully, false otherwise
+   */
+  async retractRequest(userId, token) {
+    const request = await this.validateToken(userId, token);
+    if (!request) {
+      return false;
+    }
+    await this.updateStatus(userId, request.request_id, "retracted");
+    return true;
+  }
+  /**
+   * Update request status
+   * 
+   * @param userId - User ID
+   * @param requestId - Request document ID
+   * @param status - New status
+   */
+  async updateStatus(userId, requestId, status) {
+    const collectionPath = `users/${userId}/requests`;
+    const updateData = {
+      status
+    };
+    if (status === "confirmed") {
+      updateData.confirmed_at = (/* @__PURE__ */ new Date()).toISOString();
+    }
+    await updateDocument(collectionPath, requestId, updateData);
+  }
+  /**
+   * Clean up expired requests (optional - Firestore TTL handles deletion)
+   * 
+   * Note: Configure Firestore TTL policy on 'requests' collection group
+   * with 'expires_at' field for automatic deletion within 24 hours.
+   * 
+   * This method is optional for immediate cleanup if needed.
+   * 
+   * @returns Count of deleted requests
+   */
+  async cleanupExpired() {
+    console.warn("[ConfirmationTokenService] cleanupExpired not implemented - rely on Firestore TTL");
+    return 0;
+  }
+};
+var confirmationTokenService = new ConfirmationTokenService();
+
+// src/weaviate/space-schema.ts
+init_space_memory();
+import weaviate3 from "weaviate-client";
+function getSpaceCollectionName(spaceId) {
+  return `Memory_${spaceId}`;
+}
+function isValidSpaceId(spaceId) {
+  return SUPPORTED_SPACES.includes(spaceId);
+}
+async function createSpaceCollection(client2, spaceId) {
+  const collectionName = getSpaceCollectionName(spaceId);
+  console.log(`[Weaviate] Creating space collection ${collectionName}...`);
+  await client2.collections.create({
+    name: collectionName,
+    // Vectorizer configuration
+    vectorizers: weaviate3.configure.vectorizer.text2VecOpenAI({
+      model: "text-embedding-3-small",
+      // Vectorize content for semantic search
+      sourceProperties: ["content", "observation"]
+    }),
+    properties: [
+      // Discriminator
+      {
+        name: "doc_type",
+        dataType: "text",
+        description: 'Document type: "space_memory"'
+      },
+      // Space identity
+      {
+        name: "space_id",
+        dataType: "text",
+        description: 'Space identifier (e.g., "the_void")'
+      },
+      {
+        name: "author_id",
+        dataType: "text",
+        description: "Original author user_id (for permissions)"
+      },
+      {
+        name: "ghost_id",
+        dataType: "text",
+        description: "Optional ghost profile ID for pseudonymous publishing"
+      },
+      {
+        name: "attribution",
+        dataType: "text",
+        description: 'Attribution type: "user" or "ghost"'
+      },
+      // Discovery metadata
+      {
+        name: "published_at",
+        dataType: "text",
+        description: "When published to space (ISO 8601)"
+      },
+      {
+        name: "discovery_count",
+        dataType: "number",
+        description: "How many times discovered"
+      },
+      // Memory fields (same as personal memories)
+      {
+        name: "content",
+        dataType: "text",
+        description: "Main memory content (vectorized)"
+      },
+      {
+        name: "title",
+        dataType: "text",
+        description: "Optional short title"
+      },
+      {
+        name: "summary",
+        dataType: "text",
+        description: "Optional brief summary"
+      },
+      {
+        name: "type",
+        dataType: "text",
+        description: "Content type (note, event, person, etc.)"
+      },
+      // Scoring fields
+      {
+        name: "weight",
+        dataType: "number",
+        description: "Significance/priority (0-1)"
+      },
+      {
+        name: "trust",
+        dataType: "number",
+        description: "Access control level (0-1)"
+      },
+      {
+        name: "confidence",
+        dataType: "number",
+        description: "System confidence in accuracy (0-1)"
+      },
+      // Location fields (flattened)
+      {
+        name: "location_gps_latitude",
+        dataType: "number",
+        description: "GPS latitude"
+      },
+      {
+        name: "location_gps_longitude",
+        dataType: "number",
+        description: "GPS longitude"
+      },
+      {
+        name: "location_address_formatted",
+        dataType: "text",
+        description: "Formatted address"
+      },
+      {
+        name: "location_address_city",
+        dataType: "text",
+        description: "City"
+      },
+      {
+        name: "location_address_country",
+        dataType: "text",
+        description: "Country"
+      },
+      // Context fields (flattened)
+      {
+        name: "context_conversation_id",
+        dataType: "text",
+        description: "Conversation ID"
+      },
+      {
+        name: "context_platform",
+        dataType: "text",
+        description: "Platform where created"
+      },
+      // Tags and relationships
+      {
+        name: "tags",
+        dataType: "text[]",
+        description: "Tags for categorization"
+      },
+      {
+        name: "related_memory_ids",
+        dataType: "text[]",
+        description: "IDs of related memories"
+      },
+      // Timestamps
+      {
+        name: "created_at",
+        dataType: "text",
+        description: "Original creation timestamp (ISO 8601)"
+      },
+      {
+        name: "updated_at",
+        dataType: "text",
+        description: "Last update timestamp (ISO 8601)"
+      },
+      // Versioning
+      {
+        name: "version",
+        dataType: "number",
+        description: "Version number (increments on update)"
+      }
+    ]
+  });
+  console.log(`[Weaviate] Space collection ${collectionName} created successfully`);
+}
+async function ensureSpaceCollection(client2, spaceId) {
+  if (!isValidSpaceId(spaceId)) {
+    throw new Error(`Invalid space ID: ${spaceId}. Supported spaces: ${SUPPORTED_SPACES.join(", ")}`);
+  }
+  const collectionName = getSpaceCollectionName(spaceId);
+  const exists = await client2.collections.exists(collectionName);
+  if (!exists) {
+    await createSpaceCollection(client2, spaceId);
+  }
+  return client2.collections.get(collectionName);
+}
+
+// src/tools/publish.ts
+init_space_memory();
+var publishTool = {
+  name: "remember_publish",
+  description: 'Publish a memory to a shared space (like "The Void"). The memory will be COPIED (not moved) from your personal collection. Generates a confirmation token. Use remember_confirm to execute.',
+  inputSchema: {
+    type: "object",
+    properties: {
+      memory_id: {
+        type: "string",
+        description: "ID of the memory from your personal collection to publish"
+      },
+      target: {
+        type: "string",
+        description: "Target space to publish to (snake_case ID)",
+        enum: SUPPORTED_SPACES,
+        default: "the_void"
+      },
+      additional_tags: {
+        type: "array",
+        items: { type: "string" },
+        description: "Additional tags for discovery (merged with original tags)",
+        default: []
+      }
+    },
+    required: ["memory_id", "target"]
+  }
+};
+async function handlePublish(args, userId) {
+  try {
+    console.log("[remember_publish] Starting publish request:", {
+      userId,
+      memoryId: args.memory_id,
+      target: args.target,
+      additionalTags: args.additional_tags?.length || 0
+    });
+    if (!isValidSpaceId(args.target)) {
+      console.log("[remember_publish] Invalid space ID:", args.target);
+      return JSON.stringify(
+        {
+          success: false,
+          error: "Invalid space ID",
+          message: `Space "${args.target}" is not supported. Supported spaces: ${SUPPORTED_SPACES.join(", ")}`,
+          context: {
+            provided_space: args.target,
+            supported_spaces: SUPPORTED_SPACES
+          }
+        },
+        null,
+        2
+      );
+    }
+    const weaviateClient = getWeaviateClient();
+    const collectionName = getMemoryCollectionName(userId);
+    console.log("[remember_publish] Fetching memory from collection:", collectionName);
+    const userCollection = weaviateClient.collections.get(collectionName);
+    const memory = await userCollection.query.fetchObjectById(args.memory_id);
+    console.log("[remember_publish] Memory fetch result:", {
+      found: !!memory,
+      memoryId: args.memory_id
+    });
+    if (!memory) {
+      console.log("[remember_publish] Memory not found");
+      return JSON.stringify(
+        {
+          success: false,
+          error: "Memory not found",
+          message: `No memory found with ID: ${args.memory_id}`,
+          context: {
+            collection_name: getMemoryCollectionName(userId),
+            memory_id: args.memory_id
+          }
+        },
+        null,
+        2
+      );
+    }
+    if (memory.properties.user_id !== userId) {
+      return JSON.stringify(
+        {
+          success: false,
+          error: "Permission denied",
+          message: "You can only publish your own memories",
+          context: {
+            memory_id: args.memory_id,
+            memory_owner: memory.properties.user_id,
+            requesting_user: userId
+          }
+        },
+        null,
+        2
+      );
+    }
+    if (memory.properties.doc_type !== "memory") {
+      return JSON.stringify(
+        {
+          success: false,
+          error: "Invalid document type",
+          message: "Only memories can be published (not relationships)",
+          context: {
+            memory_id: args.memory_id,
+            doc_type: memory.properties.doc_type
+          }
+        },
+        null,
+        2
+      );
+    }
+    const payload = {
+      memory_id: args.memory_id,
+      additional_tags: args.additional_tags || []
+    };
+    console.log("[remember_publish] Generating confirmation token");
+    const { requestId, token } = await confirmationTokenService.createRequest(
+      userId,
+      "publish_memory",
+      payload,
+      args.target
+    );
+    console.log("[remember_publish] Token generated:", {
+      requestId,
+      token,
+      action: "publish_memory"
+    });
+    return JSON.stringify(
+      {
+        success: true,
+        token
+      },
+      null,
+      2
+    );
+  } catch (error) {
+    handleToolError(error, {
+      toolName: "remember_publish",
+      userId,
+      operation: "publish memory",
+      memory_id: args.memory_id,
+      target: args.target
+    });
+  }
+}
+
+// src/tools/confirm.ts
+var confirmTool = {
+  name: "remember_confirm",
+  description: "Confirm and execute a pending action using the token. Works for any action that requires confirmation (publish, delete, etc.).",
+  inputSchema: {
+    type: "object",
+    properties: {
+      token: {
+        type: "string",
+        description: "The confirmation token from the action tool"
+      }
+    },
+    required: ["token"]
+  }
+};
+async function handleConfirm(args, userId) {
+  try {
+    console.log("[remember_confirm] Starting confirmation:", {
+      userId,
+      token: args.token
+    });
+    const request = await confirmationTokenService.confirmRequest(userId, args.token);
+    console.log("[remember_confirm] Token validation result:", {
+      requestFound: !!request,
+      action: request?.action
+    });
+    if (!request) {
+      console.log("[remember_confirm] Token invalid or expired");
+      return JSON.stringify(
+        {
+          success: false,
+          error: "Invalid or expired token",
+          message: "The confirmation token is invalid, expired, or has already been used."
+        },
+        null,
+        2
+      );
+    }
+    console.log("[remember_confirm] Executing action:", request.action);
+    if (request.action === "publish_memory") {
+      return await executePublishMemory(request, userId);
+    }
+    throw new Error(`Unknown action type: ${request.action}`);
+  } catch (error) {
+    handleToolError(error, {
+      toolName: "remember_confirm",
+      userId,
+      operation: "confirm action",
+      token: args.token
+    });
+  }
+}
+async function executePublishMemory(request, userId) {
+  try {
+    console.log("[executePublishMemory] Starting execution:", {
+      userId,
+      memoryId: request.payload.memory_id,
+      targetSpace: request.target_collection
+    });
+    const weaviateClient = getWeaviateClient();
+    const userCollection = weaviateClient.collections.get(
+      getMemoryCollectionName(userId)
+    );
+    console.log("[executePublishMemory] Fetching original memory from:", getMemoryCollectionName(userId));
+    const originalMemory = await userCollection.query.fetchObjectById(
+      request.payload.memory_id
+    );
+    console.log("[executePublishMemory] Original memory fetch result:", {
+      found: !!originalMemory,
+      memoryId: request.payload.memory_id
+    });
+    if (!originalMemory) {
+      console.log("[executePublishMemory] Memory not found");
+      return JSON.stringify(
+        {
+          success: false,
+          error: "Memory not found",
+          message: `Original memory ${request.payload.memory_id} no longer exists`
+        },
+        null,
+        2
+      );
+    }
+    if (originalMemory.properties.user_id !== userId) {
+      console.log("[executePublishMemory] Permission denied - wrong owner");
+      return JSON.stringify(
+        {
+          success: false,
+          error: "Permission denied",
+          message: "You can only publish your own memories"
+        },
+        null,
+        2
+      );
+    }
+    console.log("[executePublishMemory] Ensuring space collection:", request.target_collection || "the_void");
+    const targetCollection = await ensureSpaceCollection(
+      weaviateClient,
+      request.target_collection || "the_void"
+    );
+    console.log("[executePublishMemory] Space collection ready");
+    const originalTags = Array.isArray(originalMemory.properties.tags) ? originalMemory.properties.tags : [];
+    const additionalTags = Array.isArray(request.payload.additional_tags) ? request.payload.additional_tags : [];
+    const publishedMemory = {
+      ...originalMemory.properties,
+      // Override specific fields
+      space_id: request.target_collection || "the_void",
+      author_id: userId,
+      // Always attributed
+      published_at: (/* @__PURE__ */ new Date()).toISOString(),
+      discovery_count: 0,
+      doc_type: "space_memory",
+      attribution: "user",
+      // Merge additional tags
+      tags: [...originalTags, ...additionalTags],
+      // Update timestamps
+      created_at: (/* @__PURE__ */ new Date()).toISOString(),
+      updated_at: (/* @__PURE__ */ new Date()).toISOString(),
+      version: 1
+    };
+    console.log("[executePublishMemory] Inserting into space collection:", {
+      spaceId: request.target_collection || "the_void",
+      memoryId: request.payload.memory_id,
+      hasProperties: !!publishedMemory
+    });
+    const result = await targetCollection.data.insert({
+      properties: publishedMemory
+    });
+    console.log("[executePublishMemory] Insert result:", {
+      success: !!result,
+      spaceMemoryId: result
+    });
+    return JSON.stringify(
+      {
+        success: true,
+        space_memory_id: result
+      },
+      null,
+      2
+    );
+  } catch (error) {
+    handleToolError(error, {
+      toolName: "remember_confirm",
+      userId,
+      operation: "execute publish_memory",
+      action: "publish_memory"
+    });
+  }
+}
+
+// src/tools/deny.ts
+var denyTool = {
+  name: "remember_deny",
+  description: "Deny a pending action. The request will be marked as denied and the token invalidated. Works for any action that requires confirmation.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      token: {
+        type: "string",
+        description: "The confirmation token from the action tool"
+      }
+    },
+    required: ["token"]
+  }
+};
+async function handleDeny(args, userId) {
+  try {
+    const success = await confirmationTokenService.denyRequest(userId, args.token);
+    if (!success) {
+      return JSON.stringify(
+        {
+          success: false,
+          error: "Invalid token",
+          message: "Token not found or already used"
+        },
+        null,
+        2
+      );
+    }
+    return JSON.stringify(
+      {
+        success: true
+      },
+      null,
+      2
+    );
+  } catch (error) {
+    handleToolError(error, {
+      toolName: "remember_deny",
+      userId,
+      operation: "deny action",
+      token: args.token
+    });
+  }
+}
+
+// src/tools/search-space.ts
+import { Filters as Filters3 } from "weaviate-client";
+init_space_memory();
+var searchSpaceTool = {
+  name: "remember_search_space",
+  description: "Search shared spaces to discover thoughts, ideas, and memories. Works like remember_search_memory but searches shared spaces instead of personal memories.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      query: {
+        type: "string",
+        description: "Search query (semantic + keyword hybrid)"
+      },
+      space: {
+        type: "string",
+        description: "Which space to search",
+        enum: SUPPORTED_SPACES,
+        default: "the_void"
+      },
+      content_type: {
+        type: "string",
+        description: "Filter by content type"
+      },
+      tags: {
+        type: "array",
+        items: { type: "string" },
+        description: "Filter by tags (must have all specified tags)"
+      },
+      min_weight: {
+        type: "number",
+        minimum: 0,
+        maximum: 1,
+        description: "Minimum weight/significance (0-1)"
+      },
+      max_weight: {
+        type: "number",
+        minimum: 0,
+        maximum: 1,
+        description: "Maximum weight/significance (0-1)"
+      },
+      date_from: {
+        type: "string",
+        description: "Filter memories created after this date (ISO 8601)"
+      },
+      date_to: {
+        type: "string",
+        description: "Filter memories created before this date (ISO 8601)"
+      },
+      limit: {
+        type: "number",
+        default: 10,
+        description: "Maximum number of results"
+      },
+      offset: {
+        type: "number",
+        default: 0,
+        description: "Offset for pagination"
+      }
+    },
+    required: ["query", "space"]
+  }
+};
+async function handleSearchSpace(args, userId) {
+  try {
+    if (!isValidSpaceId(args.space)) {
+      return JSON.stringify(
+        {
+          success: false,
+          error: "Invalid space ID",
+          message: `Space "${args.space}" is not supported. Supported spaces: ${SUPPORTED_SPACES.join(", ")}`
+        },
+        null,
+        2
+      );
+    }
+    const weaviateClient = getWeaviateClient();
+    const spaceCollection = await ensureSpaceCollection(weaviateClient, args.space);
+    const filterList = [];
+    filterList.push(spaceCollection.filter.byProperty("space_id").equal(args.space));
+    filterList.push(spaceCollection.filter.byProperty("doc_type").equal("space_memory"));
+    if (args.content_type) {
+      filterList.push(spaceCollection.filter.byProperty("type").equal(args.content_type));
+    }
+    if (args.tags && args.tags.length > 0) {
+      args.tags.forEach((tag) => {
+        filterList.push(spaceCollection.filter.byProperty("tags").containsAny([tag]));
+      });
+    }
+    if (args.min_weight !== void 0) {
+      filterList.push(spaceCollection.filter.byProperty("weight").greaterOrEqual(args.min_weight));
+    }
+    if (args.max_weight !== void 0) {
+      filterList.push(spaceCollection.filter.byProperty("weight").lessOrEqual(args.max_weight));
+    }
+    if (args.date_from) {
+      filterList.push(spaceCollection.filter.byProperty("created_at").greaterOrEqual(new Date(args.date_from)));
+    }
+    if (args.date_to) {
+      filterList.push(spaceCollection.filter.byProperty("created_at").lessOrEqual(new Date(args.date_to)));
+    }
+    const whereFilter = filterList.length > 0 ? Filters3.and(...filterList) : void 0;
+    const searchResults = await spaceCollection.query.hybrid(args.query, {
+      limit: args.limit || 10,
+      offset: args.offset || 0,
+      ...whereFilter && { where: whereFilter }
+    });
+    const memories = searchResults.objects.map((obj) => ({
+      id: obj.uuid,
+      ...obj.properties,
+      _score: obj.metadata?.score
+    }));
+    const result = {
+      space: args.space,
+      query: args.query,
+      memories,
+      total: memories.length,
+      offset: args.offset || 0,
+      limit: args.limit || 10
+    };
+    return JSON.stringify(result, null, 2);
+  } catch (error) {
+    handleToolError(error, {
+      toolName: "remember_search_space",
+      operation: "search space",
+      space: args.space,
+      query: args.query
+    });
+  }
+}
+
+// src/tools/query-space.ts
+import { Filters as Filters4 } from "weaviate-client";
+init_space_memory();
+var querySpaceTool = {
+  name: "remember_query_space",
+  description: "Ask natural language questions about memories in shared spaces. Works like remember_query_memory but queries shared spaces.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      question: {
+        type: "string",
+        description: "Natural language question"
+      },
+      space: {
+        type: "string",
+        description: "Which space to query",
+        enum: SUPPORTED_SPACES,
+        default: "the_void"
+      },
+      content_type: {
+        type: "string",
+        description: "Filter by content type"
+      },
+      tags: {
+        type: "array",
+        items: { type: "string" },
+        description: "Filter by tags"
+      },
+      min_weight: {
+        type: "number",
+        minimum: 0,
+        maximum: 1,
+        description: "Minimum weight/significance (0-1)"
+      },
+      date_from: {
+        type: "string",
+        description: "Filter memories created after this date (ISO 8601)"
+      },
+      date_to: {
+        type: "string",
+        description: "Filter memories created before this date (ISO 8601)"
+      },
+      limit: {
+        type: "number",
+        default: 10,
+        description: "Maximum number of results"
+      },
+      format: {
+        type: "string",
+        enum: ["detailed", "compact"],
+        default: "detailed",
+        description: "Output format: detailed (full objects) or compact (text summary)"
+      }
+    },
+    required: ["question", "space"]
+  }
+};
+async function handleQuerySpace(args, userId) {
+  try {
+    if (!isValidSpaceId(args.space)) {
+      return JSON.stringify(
+        {
+          success: false,
+          error: "Invalid space ID",
+          message: `Space "${args.space}" is not supported. Supported spaces: ${SUPPORTED_SPACES.join(", ")}`
+        },
+        null,
+        2
+      );
+    }
+    const weaviateClient = getWeaviateClient();
+    const spaceCollection = await ensureSpaceCollection(weaviateClient, args.space);
+    const filterList = [];
+    filterList.push(spaceCollection.filter.byProperty("space_id").equal(args.space));
+    filterList.push(spaceCollection.filter.byProperty("doc_type").equal("space_memory"));
+    if (args.content_type) {
+      filterList.push(spaceCollection.filter.byProperty("type").equal(args.content_type));
+    }
+    if (args.tags && args.tags.length > 0) {
+      args.tags.forEach((tag) => {
+        filterList.push(spaceCollection.filter.byProperty("tags").containsAny([tag]));
+      });
+    }
+    if (args.min_weight !== void 0) {
+      filterList.push(spaceCollection.filter.byProperty("weight").greaterOrEqual(args.min_weight));
+    }
+    if (args.date_from) {
+      filterList.push(spaceCollection.filter.byProperty("created_at").greaterOrEqual(new Date(args.date_from)));
+    }
+    if (args.date_to) {
+      filterList.push(spaceCollection.filter.byProperty("created_at").lessOrEqual(new Date(args.date_to)));
+    }
+    const whereFilter = filterList.length > 0 ? Filters4.and(...filterList) : void 0;
+    const searchResults = await spaceCollection.query.nearText(args.question, {
+      limit: args.limit || 10,
+      ...whereFilter && { where: whereFilter }
+    });
+    const format = args.format || "detailed";
+    if (format === "compact") {
+      const summaries = searchResults.objects.map((obj, idx) => {
+        const props = obj.properties;
+        return `${idx + 1}. ${props.title || props.content?.substring(0, 100) || "Untitled"}`;
+      });
+      const result = {
+        question: args.question,
+        space: args.space,
+        format: "compact",
+        summary: summaries.join("\n"),
+        count: searchResults.objects.length
+      };
+      return JSON.stringify(result, null, 2);
+    } else {
+      const memories = searchResults.objects.map((obj) => ({
+        id: obj.uuid,
+        ...obj.properties,
+        _distance: obj.metadata?.distance
+      }));
+      const result = {
+        question: args.question,
+        space: args.space,
+        format: "detailed",
+        memories,
+        total: memories.length
+      };
+      return JSON.stringify(result, null, 2);
+    }
+  } catch (error) {
+    handleToolError(error, {
+      toolName: "remember_query_space",
+      operation: "query space",
+      space: args.space,
+      question: args.question
+    });
+  }
+}
+
 // src/server.ts
 async function initServer() {
   logger.info("Initializing remember-mcp server...");
@@ -3293,7 +4271,13 @@ function registerHandlers(server) {
         deleteRelationshipTool,
         // Preference tools
         setPreferenceTool,
-        getPreferencesTool
+        getPreferencesTool,
+        // Space tools
+        publishTool,
+        confirmTool,
+        denyTool,
+        searchSpaceTool,
+        querySpaceTool
       ]
     };
   });
@@ -3339,6 +4323,21 @@ function registerHandlers(server) {
         case "remember_get_preferences":
           result = await handleGetPreferences(args, userId);
           break;
+        case "remember_publish":
+          result = await handlePublish(args, userId);
+          break;
+        case "remember_confirm":
+          result = await handleConfirm(args, userId);
+          break;
+        case "remember_deny":
+          result = await handleDeny(args, userId);
+          break;
+        case "remember_search_space":
+          result = await handleSearchSpace(args, userId);
+          break;
+        case "remember_query_space":
+          result = await handleQuerySpace(args, userId);
+          break;
         default:
           throw new McpError(
             ErrorCode.MethodNotFound,