clay-server 4.0.0-beta.2 → 4.0.0-beta.21

package/lib/project-logs.js

@@ -0,0 +1,400 @@
+// Project Logs message handling and session-bound MCP wiring.
+//
+// Every capability here is derived server-side. The WebSocket path binds from
+// ws._clayUser plus this project's own slug, and the MCP path binds from the
+// exact live session object. Neither accepts identity or project scope from
+// the message, so a client cannot widen its own reach by asking.
+//
+// Authorship is split deliberately. Canonical entries are created and revised
+// only by this project's agent sessions through `clay-logs`; a connected human
+// reads the ledger, appends attributed comments, and lets the project owner
+// delete an entry. That keeps the log an honest record rather than a wiki.
+
+var logsMcp = require("./project-logs-mcp-server");
+
+var LIST_LIMIT = 50;
+var MAX_NOTICE_TITLE_CHARS = 160;
+var MAX_NOTICE_SUMMARY_CHARS = 240;
+
+// Canonical writes that move the ledger forward. A plain comment, a
+// clarification, and a decline are participation, not revisions, so they never
+// notify.
+var NOTIFYING_OPS = ["create", "update", "link", "incorporate", "revert", "delete"];
+
+function clip(value, max) {
+  if (typeof value !== "string") return "";
+  return value.length > max ? value.substring(0, max) : value;
+}
+
+// Bounded ledger metadata only. No body, no comment text, no author identity
+// beyond the vendor that wrote it.
+function updateNotice(entry, op) {
+  return {
+    type: "project_log_updated",
+    ref: entry.ref,
+    revision: entry.revisions,
+    op: op,
+    category: entry.category,
+    priority: entry.priority,
+    title: clip(entry.title, MAX_NOTICE_TITLE_CHARS),
+    summary: clip(entry.summary, MAX_NOTICE_SUMMARY_CHARS),
+    at: entry.updatedAt,
+    vendor: (entry.updatedBy && entry.updatedBy.vendor) || null,
+  };
+}
+
+var SYSTEM_PROMPT_LABEL = "--- Project Logs (durable project record; manage via clay-logs tools) ---";
+
+function parseJsonArray(value) {
+  if (Array.isArray(value)) return value;
+  if (typeof value !== "string" || !value.trim()) return undefined;
+  var parsed;
+  try {
+    parsed = JSON.parse(value);
+  } catch (e) {
+    throw new Error("Expected a JSON array.");
+  }
+  if (!Array.isArray(parsed)) throw new Error("Expected a JSON array.");
+  return parsed;
+}
+
+// The tool surface accepts JSON-encoded arrays because MCP shapes are flat
+// scalars. The service and store only ever see real arrays.
+function coerceToolArgs(args) {
+  var out = Object.assign({}, args || {});
+  if (out.tags !== undefined) out.tags = parseJsonArray(out.tags);
+  if (out.links !== undefined) out.links = parseJsonArray(out.links);
+  return out;
+}
+
+var HANDLED_TYPES = [
+  "project_logs_list",
+  "project_log_read",
+  "project_log_comment",
+  "project_log_delete",
+  // Retired human mutations. Still claimed so an older client gets an
+  // explicit refusal rather than silence.
+  "project_log_create",
+  "project_log_update",
+];
+
+var RETIRED_TYPES = ["project_log_create", "project_log_update"];
+
+function attachProjectLogs(ctx) {
+  var service = ctx.service;
+  var sm = ctx.sm;
+  var slug = ctx.projectSlug;
+  var isMate = ctx.isMate === true;
+  var mateId = ctx.mateId || null;
+  var sendTo = ctx.sendTo;
+  var getClients = ctx.getClients || function () { return []; };
+  var getProjectOwnerId = ctx.getProjectOwnerId || function () { return null; };
+  var onFeedback = ctx.onFeedback || function () {};
+
+  // Every socket in this project's client set passed the project access check
+  // at WebSocket upgrade, so a broadcast here is already scoped to authorized
+  // human users of this project. Nothing is read from any payload. Pane
+  // connections are excluded, matching how sticky notes broadcast.
+  function broadcastUpdate(entry, op) {
+    if (isMate || !entry) return;
+    if (NOTIFYING_OPS.indexOf(op) === -1) return;
+    var notice = updateNotice(entry, op);
+    var clients = getClients();
+    for (var client of clients) {
+      if (!client || client.readyState !== 1 || client._clayPane) continue;
+      sendTo(client, notice);
+    }
+  }
+
+  function broadcastCommentReview(entry, request) {
+    if (isMate || !entry || !request || !request.commentId) return;
+    var notice = {
+      type: "project_log_comment_reviewed",
+      ref: entry.ref,
+      commentId: request.commentId,
+      action: request.action,
+    };
+    var clients = getClients();
+    for (var client of clients) {
+      if (!client || client.readyState !== 1 || client._clayPane) continue;
+      sendTo(client, notice);
+    }
+  }
+
+  // Wrap a canonical write so a successful one notifies. A throw never reaches
+  // here, so a failed or no-op write is silent.
+  function notifying(op, run) {
+    return function (args) {
+      var result = run(args);
+      broadcastUpdate(result, op);
+      return result;
+    };
+  }
+
+  // --- Bindings --------------------------------------------------------
+
+  function sessionBinding(session) {
+    if (!service) return null;
+    if (isMate) {
+      if (!mateId) return null;
+      if (session && (!sm || !sm.sessions || sm.sessions.get(session.localId) !== session)) return null;
+      return service.bindMate({
+        projectSlug: slug,
+        projectOwnerId: getProjectOwnerId(),
+        isMate: true,
+        mateId: mateId,
+        session: session || null,
+      });
+    }
+    if (!session) return null;
+    return service.bindProjectSession({ projectSlug: slug, session: session });
+  }
+
+  function userBinding(ws) {
+    if (!service || isMate) return null;
+    return service.bindUser({ projectSlug: slug, user: (ws && ws._clayUser) || null });
+  }
+
+  // --- WebSocket surface -----------------------------------------------
+
+  function fail(ws, requestId, message) {
+    sendTo(ws, { type: "project_logs_error", requestId: requestId || null, message: message });
+  }
+
+  // Search already returns the ledger row shape, so a query needs no per-hit
+  // read and neither path dumps a record body into the list.
+  // Returns both the rows and this project's live category vocabulary, so the
+  // filter is populated solely from what this project actually uses.
+  function listEntries(bound, query, category, contextMode) {
+    var options = { kind: category, limit: LIST_LIMIT, contextMode: contextMode };
+    if (query) {
+      options.query = query;
+      var hits = bound.searchLogs(options);
+      return {
+        entries: hits.results,
+        categories: hits.categories || [],
+        contextMode: hits.contextMode,
+        currentChangeSetId: hits.currentChangeSetId,
+        isWorktree: hits.isWorktree,
+      };
+    }
+    var listed = bound.listLogs(options);
+    return {
+      entries: listed.entries,
+      categories: listed.categories || [],
+      contextMode: listed.contextMode,
+      currentChangeSetId: listed.currentChangeSetId,
+      isWorktree: listed.isWorktree,
+    };
+  }
+
+  function handleLogsMessage(ws, msg) {
+    if (!msg || typeof msg.type !== "string") return false;
+    if (HANDLED_TYPES.indexOf(msg.type) === -1) return false;
+
+    var requestId = typeof msg.requestId === "string" ? msg.requestId : null;
+    if (isMate) {
+      fail(ws, requestId, "Project Logs are available in projects, not in Mate conversations.");
+      return true;
+    }
+
+    // Canonical authorship belongs to the project's agent sessions. A human
+    // asking to create or revise is refused before any binding is attempted,
+    // so no privilege level can reach the canonical writers.
+    if (RETIRED_TYPES.indexOf(msg.type) !== -1) {
+      fail(ws, requestId, "Project Logs are written by this project's agent sessions. Add a comment instead.");
+      return true;
+    }
+
+    var bound = userBinding(ws);
+    if (!bound) {
+      fail(ws, requestId, "Project Logs are not available for this project.");
+      return true;
+    }
+
+    try {
+      if (msg.type === "project_logs_list") {
+        var query = typeof msg.query === "string" ? msg.query.trim() : "";
+        // A view preference, not an authorization input: the store validates it.
+        var category = typeof msg.category === "string" && msg.category ? msg.category : null;
+        var contextMode = typeof msg.contextMode === "string" ? msg.contextMode : null;
+        var listing = listEntries(bound, query, category, contextMode);
+        sendTo(ws, {
+          type: "project_logs_state",
+          requestId: requestId,
+          entries: listing.entries,
+          categories: listing.categories,
+          contextMode: listing.contextMode,
+          currentChangeSetId: listing.currentChangeSetId,
+          isWorktree: listing.isWorktree === true,
+          canDelete: bound.canDelete === true,
+        });
+        return true;
+      }
+
+      if (msg.type === "project_log_read") {
+        sendTo(ws, { type: "project_log_entry", requestId: requestId, entry: bound.readLog({ ref: msg.ref }), canDelete: bound.canDelete === true });
+        return true;
+      }
+
+      if (msg.type === "project_log_delete") {
+        var removed = bound.removeLog({ ref: msg.ref });
+        sendTo(ws, { type: "project_log_deleted", requestId: requestId, ref: removed.ref });
+        broadcastUpdate(removed, "delete");
+        return true;
+      }
+
+      if (msg.type === "project_log_comment") {
+        var commented = bound.commentLog({ ref: msg.ref, body: msg.body });
+        var reviewQueued = false;
+        try { reviewQueued = onFeedback(commented) === true; } catch (deliveryError) {
+          console.error("[project-logs] Failed to deliver comment:", deliveryError.message || deliveryError);
+        }
+        sendTo(ws, { type: "project_log_commented", requestId: requestId, entry: commented, reviewQueued: reviewQueued });
+        return true;
+      }
+    } catch (e) {
+      fail(ws, requestId, (e && e.message) || "Project Logs could not complete the request.");
+      return true;
+    }
+
+    return false;
+  }
+
+  // --- MCP surface ------------------------------------------------------
+
+  function toolHandlers(bound) {
+    if (!bound) return null;
+    return {
+      listLogs: function (args) { return bound.listLogs(args || {}); },
+      searchLogs: function (args) { return bound.searchLogs(args || {}); },
+      readLog: function (args) { return bound.readLog(args || {}); },
+      logHistory: function (args) { return bound.logHistory(args || {}); },
+      readLogRevision: function (args) { return bound.readLogRevision(args || {}); },
+      listLogFeedback: function (args) { return bound.listLogFeedback(args || {}); },
+      reviewLogComment: function (args) {
+        var request = coerceToolArgs(args);
+        var result = bound.reviewLogComment(request);
+        broadcastCommentReview(result, request);
+        // Only an incorporation is a canonical revision; clarify and decline
+        // resolve a comment and change nothing.
+        if (request && request.action === "incorporate") broadcastUpdate(result, "incorporate");
+        return result;
+      },
+      revertLog: notifying("revert", function (args) { return bound.revertLog(args || {}); }),
+      createLog: notifying("create", function (args) { return bound.createLog(coerceToolArgs(args)); }),
+      updateLog: notifying("update", function (args) { return bound.updateLog(coerceToolArgs(args)); }),
+      linkLog: notifying("link", function (args) { return bound.linkLog(coerceToolArgs(args)); }),
+    };
+  }
+
+  // A Mate project advertises tools only when the registry confirms
+  // authoritative builtin Clay, and then only the read-only cross-project set.
+  function includeGlobal() {
+    if (!isMate) return false;
+    var projectBound = sessionBinding(null);
+    return !!(projectBound && projectBound.isClay === true);
+  }
+
+  function getToolDefs(session) {
+    if (!service) return [];
+    if (isMate && !includeGlobal()) return [];
+    var bound = session ? sessionBinding(session) : null;
+    if (session && !bound) return [];
+    return logsMcp.getToolDefs(toolHandlers(bound), isMate);
+  }
+
+  function createMcpServer(adapter, session) {
+    if (!service) return null;
+    if (isMate && !includeGlobal()) return null;
+    if (!isMate && session && !sessionBinding(session)) {
+      // A session that cannot bind still gets the fail-closed descriptor
+      // rather than a silently missing server.
+      return logsMcp.createMcpServer(adapter, null, false);
+    }
+    var bound = session ? sessionBinding(session) : null;
+    return logsMcp.createMcpServer(adapter, toolHandlers(bound), isMate);
+  }
+
+  function getDynamicToolDefs(session) {
+    return getToolDefs(session).map(function (tool) {
+      tool.permissionName = "mcp__clay-logs__" + tool.name;
+      return tool;
+    });
+  }
+
+  function getBridgeTools(session, normalizeSchema) {
+    if (!session) return [];
+    var defs = getToolDefs(session);
+    var tools = [];
+    for (var i = 0; i < defs.length; i++) {
+      tools.push({
+        server: "clay-logs",
+        name: defs[i].name,
+        description: defs[i].description || defs[i].name,
+        inputSchema: normalizeSchema(defs[i].inputSchema),
+      });
+    }
+    return tools;
+  }
+
+  function callBridgeTool(session, toolName, args) {
+    if (!session) return Promise.reject(new Error("Project Logs require a valid session."));
+    var defs = getToolDefs(session);
+    for (var i = 0; i < defs.length; i++) {
+      if (defs[i].name === toolName) return Promise.resolve(defs[i].handler(args || {}));
+    }
+    return Promise.reject(new Error("Project Logs tool not found: " + toolName));
+  }
+
+  // A count only. The comment bodies stay in the tool, so a pending queue is
+  // discoverable on the next turn without dumping the discussion into context
+  // and without starting a turn of its own.
+  function pendingFeedbackSignal(session) {
+    if (!session) return "";
+    var bound = sessionBinding(session);
+    if (!bound || typeof bound.listLogFeedback !== "function") return "";
+    var total = 0;
+    try {
+      total = bound.listLogFeedback({ limit: 1 }).total || 0;
+    } catch (e) {
+      return "";
+    }
+    if (!total) return "";
+    return "\n" + total + (total === 1 ? " comment awaits" : " comments await") +
+      " your review. Call list_log_feedback to see them.";
+  }
+
+  function getSystemPrompt(session) {
+    if (!service) return "";
+    if (isMate) {
+      if (!includeGlobal() || (session && !sessionBinding(session))) return "";
+      return SYSTEM_PROMPT_LABEL + "\n" + logsMcp.CLAY_READ_CONTRACT;
+    }
+    if (session && !sessionBinding(session)) return "";
+    return SYSTEM_PROMPT_LABEL + "\n" + logsMcp.LOGS_CONTRACT +
+      "\n" + logsMcp.LEARNING_CONTRACT +
+      "\n" + logsMcp.ATTENTION_CONTRACT +
+      "\n" + logsMcp.REVIEW_CONTRACT + pendingFeedbackSignal(session);
+  }
+
+  return {
+    handleLogsMessage: handleLogsMessage,
+    createMcpServer: createMcpServer,
+    getToolDefs: getToolDefs,
+    getDynamicToolDefs: getDynamicToolDefs,
+    getBridgeTools: getBridgeTools,
+    callBridgeTool: callBridgeTool,
+    getSystemPrompt: getSystemPrompt,
+  };
+}
+
+module.exports = {
+  SYSTEM_PROMPT_LABEL: SYSTEM_PROMPT_LABEL,
+  NOTIFYING_OPS: NOTIFYING_OPS,
+  updateNotice: updateNotice,
+  HANDLED_TYPES: HANDLED_TYPES,
+  RETIRED_TYPES: RETIRED_TYPES,
+  attachProjectLogs: attachProjectLogs,
+  coerceToolArgs: coerceToolArgs,
+};

package/lib/project-mate-interaction.js

@@ -1,6 +1,18 @@
 var fs = require("fs");
 var path = require("path");
 var crypto = require("crypto");
+var mateSync = require("./mate-knowledge-sync");
+
+// Mirror a Mate-owned journal into the Clay-wide Knowledge backend after the
+// legacy append has already succeeded. Reconciling the whole journal keeps the
+// new scope current whether the write added, rewrote, or removed lines.
+function mirrorMateJournal(mateDir, fileName, job) {
+  mateSync.syncQuietly({
+    mateDir: mateDir,
+    fileName: fileName,
+    actor: { type: "agent", vendor: (job && job.vendor) || null, sessionKey: (job && job.sessionKey) || null },
+  });
+}
 
 function attachMateInteraction(ctx) {
   var cwd = ctx.cwd;
@@ -278,6 +290,7 @@ function attachMateInteraction(ctx) {
         fs.mkdirSync(knowledgeDir, { recursive: true });
         var digestFile = path.join(knowledgeDir, "session-digests.jsonl");
         fs.appendFileSync(digestFile, JSON.stringify(digestObj) + "\n");
+        mirrorMateJournal(mateDir, "session-digests.jsonl", job);
       } catch (e) {
         console.error("[digest-worker] Write failed for " + job.mateId + ":", e.message);
       }
@@ -302,6 +315,7 @@ function attachMateInteraction(ctx) {
             }));
           }
           fs.appendFileSync(obsFile, obsLines.join("\n") + "\n");
+          mirrorMateJournal(mateDir, "user-observations.jsonl", job);
         } catch (e) {
           console.error("[digest-worker] Observations write failed for " + job.mateId + ":", e.message);
         }

package/lib/project-mate-knowledge.js

@@ -0,0 +1,110 @@
+// Session-bound `clay-knowledge` wiring for Mate projects.
+//
+// Mate Knowledge is available only inside a Mate project. A non-Mate Project
+// Driver session gets nothing here and continues to use `clay-logs`. Which
+// tool set a Mate receives is decided by the server Mate registry through the
+// service binder, never by a project flag or a tool argument.
+
+var knowledgeMcp = require("./mate-knowledge-mcp-server");
+
+var SYSTEM_PROMPT_LABEL = "--- Your Knowledge (durable personal and expertise context; manage via clay-knowledge tools) ---";
+var CLAY_PROMPT_LABEL = "--- Mate Knowledge coordination (via clay-knowledge tools) ---";
+
+function attachProjectMateKnowledge(ctx) {
+  var service = ctx.service;
+  var sm = ctx.sm;
+  var slug = ctx.projectSlug;
+  var isMate = ctx.isMate === true;
+  var mateId = ctx.mateId || null;
+  var getProjectOwnerId = ctx.getProjectOwnerId || function () { return null; };
+
+  function binding(session) {
+    if (!service || !isMate || !mateId) return null;
+    if (session && (!sm || !sm.sessions || sm.sessions.get(session.localId) !== session)) return null;
+    return service.bind({
+      projectSlug: slug,
+      projectOwnerId: getProjectOwnerId(),
+      isMate: true,
+      mateId: mateId,
+      session: session || null,
+    });
+  }
+
+  // Decided once from the project-level binding so a static descriptor and a
+  // session-bound server always advertise the same tool set.
+  function includeClay() {
+    var projectBound = binding(null);
+    return !!(projectBound && projectBound.isClay === true);
+  }
+
+  function getToolDefs(session) {
+    if (!service || !isMate) return [];
+    var bound = session ? binding(session) : null;
+    if (session && !bound) return [];
+    return knowledgeMcp.getToolDefs(bound, includeClay());
+  }
+
+  function createMcpServer(adapter, session) {
+    if (!service || !isMate) return null;
+    if (!binding(null)) return null;
+    var bound = session ? binding(session) : null;
+    // A session that cannot bind still gets the fail-closed descriptor rather
+    // than a silently missing server.
+    return knowledgeMcp.createMcpServer(adapter, bound, includeClay());
+  }
+
+  function getDynamicToolDefs(session) {
+    return getToolDefs(session).map(function (tool) {
+      tool.permissionName = "mcp__clay-knowledge__" + tool.name;
+      return tool;
+    });
+  }
+
+  function getBridgeTools(session, normalizeSchema) {
+    if (!session) return [];
+    var defs = getToolDefs(session);
+    var tools = [];
+    for (var i = 0; i < defs.length; i++) {
+      tools.push({
+        server: "clay-knowledge",
+        name: defs[i].name,
+        description: defs[i].description || defs[i].name,
+        inputSchema: normalizeSchema(defs[i].inputSchema),
+      });
+    }
+    return tools;
+  }
+
+  function callBridgeTool(session, toolName, args) {
+    if (!session) return Promise.reject(new Error("Knowledge tools require a valid Mate session."));
+    var defs = getToolDefs(session);
+    for (var i = 0; i < defs.length; i++) {
+      if (defs[i].name === toolName) return Promise.resolve(defs[i].handler(args || {}));
+    }
+    return Promise.reject(new Error("Knowledge tool not found: " + toolName));
+  }
+
+  function getSystemPrompt(session) {
+    if (!service || !isMate) return "";
+    var bound = session ? binding(session) : binding(null);
+    if (!bound) return "";
+    return bound.isClay
+      ? CLAY_PROMPT_LABEL + "\n" + knowledgeMcp.CLAY_CONTRACT
+      : SYSTEM_PROMPT_LABEL + "\n" + knowledgeMcp.MATE_CONTRACT;
+  }
+
+  return {
+    createMcpServer: createMcpServer,
+    getToolDefs: getToolDefs,
+    getDynamicToolDefs: getDynamicToolDefs,
+    getBridgeTools: getBridgeTools,
+    callBridgeTool: callBridgeTool,
+    getSystemPrompt: getSystemPrompt,
+  };
+}
+
+module.exports = {
+  SYSTEM_PROMPT_LABEL: SYSTEM_PROMPT_LABEL,
+  CLAY_PROMPT_LABEL: CLAY_PROMPT_LABEL,
+  attachProjectMateKnowledge: attachProjectMateKnowledge,
+};

package/lib/project-memory.js

@@ -1,5 +1,17 @@
 var fs = require("fs");
 var path = require("path");
+var mateSync = require("./mate-knowledge-sync");
+
+// Mirror a Mate-owned durable memory source into the Clay-wide Knowledge
+// backend after the legacy write has already succeeded. Reconciling the source
+// covers writes, rewrites, and removals with one call.
+function mirrorMateSource(mateDir, fileName, actor) {
+  mateSync.syncQuietly({
+    mateDir: mateDir,
+    fileName: fileName,
+    actor: actor || { type: "agent" },
+  });
+}
 
 function attachMemory(ctx) {
   var cwd = ctx.cwd;
@@ -467,6 +479,7 @@ function attachMemory(ctx) {
           }
           fs.mkdirSync(knowledgeDir, { recursive: true });
           fs.writeFileSync(summaryFile, cleaned + "\n", "utf8");
+          mirrorMateSource(path.dirname(knowledgeDir), "memory-summary.md");
           console.log("[memory-summary] Updated memory-summary.md for mate " + mateId);
         } catch (e) {
           console.error("[memory-summary] Failed to write memory-summary.md for mate " + mateId + ":", e.message);
@@ -573,6 +586,7 @@ function attachMemory(ctx) {
           }
           fs.mkdirSync(knowledgeDir, { recursive: true });
           fs.writeFileSync(summaryFile, cleaned + "\n", "utf8");
+          mirrorMateSource(path.dirname(knowledgeDir), "memory-summary.md");
           console.log("[memory-summary] Generated initial memory-summary.md for mate " + mateId + " from " + digestsText.length + " digests");
         } catch (e) {
           console.error("[memory-summary] Failed to write initial memory-summary.md for mate " + mateId + ":", e.message);
@@ -666,6 +680,14 @@ function attachMemory(ctx) {
         } else {
           fs.writeFileSync(digestFile, lines.join("\n") + "\n");
         }
+        // Reconciling the journal after the rewrite tombstones the removed
+        // line, so a deleted memory does not stay active in the new backend.
+        var deleteUser = (ws && ws._clayUser) || null;
+        mirrorMateSource(cwd, "session-digests.jsonl", {
+          type: deleteUser ? "user" : "system",
+          userId: deleteUser ? deleteUser.id : null,
+          displayName: deleteUser ? (deleteUser.displayName || deleteUser.username) : null,
+        });
       }
     } catch (e) {}
     sendTo(ws, { type: "memory_deleted", index: msg.index });

package/lib/project-message-delivery.js

@@ -0,0 +1,70 @@
+// Idempotent acknowledgement support for ordinary project chat messages.
+
+var CLIENT_MESSAGE_ID_RE = /^[A-Za-z0-9._:-]{1,128}$/;
+
+function normalizeClientMessageId(value) {
+  if (typeof value !== "string" || !CLIENT_MESSAGE_ID_RE.test(value)) return null;
+  return value;
+}
+
+function ownerKey(ws) {
+  return ws && ws._clayUser && ws._clayUser.id ? String(ws._clayUser.id) : "_default";
+}
+
+function deliveryKey(ownerId, clientMessageId) {
+  return ownerId + ":" + clientMessageId;
+}
+
+function ensureRecordedMessages(session) {
+  if (session._recordedClientMessages) return session._recordedClientMessages;
+  var recorded = new Map();
+  var history = Array.isArray(session.history) ? session.history : [];
+  for (var i = 0; i < history.length; i++) {
+    var item = history[i];
+    var clientMessageId = normalizeClientMessageId(item && item.clientMessageId);
+    if (!clientMessageId) continue;
+    recorded.set(deliveryKey(item.from ? String(item.from) : "_default", clientMessageId), item);
+  }
+  session._recordedClientMessages = recorded;
+  return recorded;
+}
+
+function createProjectMessageDelivery(sendTo) {
+  function inspect(ws, session, msg) {
+    var clientMessageId = normalizeClientMessageId(msg && msg.clientMessageId);
+    if (!clientMessageId) return { clientMessageId: null, ownerId: ownerKey(ws), duplicate: false };
+    var ownerId = ownerKey(ws);
+    var recordedMessage = ensureRecordedMessages(session).get(deliveryKey(ownerId, clientMessageId)) || null;
+    return {
+      clientMessageId: clientMessageId,
+      ownerId: ownerId,
+      duplicate: !!recordedMessage,
+      recordedMessage: recordedMessage,
+    };
+  }
+
+  function markRecorded(session, receipt, message) {
+    if (!receipt || !receipt.clientMessageId) return;
+    ensureRecordedMessages(session).set(deliveryKey(receipt.ownerId, receipt.clientMessageId), message);
+  }
+
+  function acknowledge(ws, receipt, message) {
+    if (!receipt || !receipt.clientMessageId) return;
+    sendTo(ws, {
+      type: "message_ack",
+      clientMessageId: receipt.clientMessageId,
+      message: message || receipt.recordedMessage || null,
+    });
+  }
+
+  return {
+    inspect: inspect,
+    markRecorded: markRecorded,
+    acknowledge: acknowledge,
+  };
+}
+
+module.exports = {
+  createProjectMessageDelivery: createProjectMessageDelivery,
+  normalizeClientMessageId: normalizeClientMessageId,
+};