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

package/lib/notes.js

@@ -3,6 +3,7 @@ var path = require("path");
 var crypto = require("crypto");
 var config = require("./config");
 var utils = require("./utils");
+var lifecycle = require("./notes-lifecycle");
 
 function createNotesManager(opts) {
   var cwd = opts.cwd;
@@ -19,11 +20,14 @@ function createNotesManager(opts) {
     return "n_" + Date.now() + "_" + crypto.randomBytes(3).toString("hex");
   }
 
+  // Legacy files are normalized on load, never on read. Nothing is rewritten
+  // just because a note was looked at; the projected fields reach disk the next
+  // time some other write happens.
   function loadFromDisk() {
     try {
       var data = fs.readFileSync(notesFile, "utf8");
       var parsed = JSON.parse(data);
-      return parsed.notes || [];
+      return lifecycle.normalizeAll(parsed.notes || []).notes;
     } catch (e) {
       return [];
     }
@@ -56,6 +60,10 @@ function createNotesManager(opts) {
       color: data.color || "purple",
       opacity: typeof data.opacity === "number" ? data.opacity : 0.64,
       minimized: false,
+      // A new note is always an open attention item.
+      state: lifecycle.STATE_OPEN,
+      closedAt: null,
+      closedBy: null,
       zIndex: notes.length + 1,
       createdAt: now,
       updatedAt: now,
@@ -74,13 +82,20 @@ function createNotesManager(opts) {
   function update(id, changes) {
     for (var i = 0; i < notes.length; i++) {
       if (notes[i].id === id) {
-        var allowed = ["text", "x", "y", "w", "h", "color", "minimized", "hidden", "zIndex", "opacity"];
+        var allowed = ["text", "x", "y", "w", "h", "color", "minimized", "zIndex", "opacity"];
         for (var j = 0; j < allowed.length; j++) {
           var key = allowed[j];
           if (changes[key] !== undefined) {
             notes[i][key] = changes[key];
           }
         }
+        // `hidden` is the legacy spelling of the lifecycle. Route it through the
+        // transitions so state, hidden, and the close provenance can never
+        // disagree, and so an old client cannot half-apply a close.
+        if (changes.hidden !== undefined) {
+          if (changes.hidden === true) lifecycle.applyClose(notes[i], changes.actor || null, Date.now());
+          else lifecycle.applyReopen(notes[i]);
+        }
         notes[i].updatedAt = Date.now();
         saveToDisk();
         return notes[i];
@@ -89,6 +104,44 @@ function createNotesManager(opts) {
     return null;
   }
 
+  // Close a note. This is what completion means: the record stays and only its
+  // place on the active canvas changes. Idempotent.
+  function close(id, actor) {
+    for (var i = 0; i < notes.length; i++) {
+      if (notes[i].id !== id) continue;
+      if (lifecycle.applyClose(notes[i], actor || null, Date.now())) {
+        notes[i].updatedAt = Date.now();
+        saveToDisk();
+      }
+      return notes[i];
+    }
+    return null;
+  }
+
+  // Reopen a closed note. Idempotent.
+  function reopen(id) {
+    for (var i = 0; i < notes.length; i++) {
+      if (notes[i].id !== id) continue;
+      if (lifecycle.applyReopen(notes[i])) {
+        notes[i].updatedAt = Date.now();
+        saveToDisk();
+      }
+      return notes[i];
+    }
+    return null;
+  }
+
+  function openList() {
+    return lifecycle.openNotes(notes);
+  }
+
+  function closedList() {
+    return lifecycle.closedNotes(notes);
+  }
+
+  // Permanent deletion. Deliberately not reachable from any WebSocket message,
+  // MCP tool, or UI control: completion closes, it never erases. Retained only
+  // for maintenance callers that must truly discard a record.
   function remove(id) {
     for (var i = 0; i < notes.length; i++) {
       if (notes[i].id === id) {
@@ -123,7 +176,7 @@ function createNotesManager(opts) {
   function getActiveNotesText() {
     var active = [];
     for (var i = 0; i < notes.length; i++) {
-      if (!notes[i].hidden && notes[i].text) active.push(notes[i]);
+      if (lifecycle.isOpen(notes[i]) && notes[i].text) active.push(notes[i]);
     }
     if (active.length === 0) return "";
     var lines = [];
@@ -137,8 +190,12 @@ function createNotesManager(opts) {
 
   return {
     list: list,
+    openList: openList,
+    closedList: closedList,
     create: create,
     update: update,
+    close: close,
+    reopen: reopen,
     remove: remove,
     bringToFront: bringToFront,
     getActiveNotesText: getActiveNotesText,

package/lib/os-users.js

@@ -161,7 +161,9 @@ function fsAsUser(op, args, osUserInfo) {
       "var fs = require('fs');",
       "var f = " + JSON.stringify(args.file) + ";",
       "var content = " + JSON.stringify(args.content || "") + ";",
-      "fs.writeFileSync(f, content, 'utf8');",
+      "var flag = " + JSON.stringify(args.flag === "wx" ? "wx" : "w") + ";",
+      "var mode = " + JSON.stringify(typeof args.mode === "number" ? args.mode : 0o666) + ";",
+      "fs.writeFileSync(f, content, { encoding: 'utf8', flag: flag, mode: mode });",
       "process.stdout.write(JSON.stringify({ ok: true }));",
     ].join(" ");
   } else if (op === "mkdir") {

package/lib/project-capsule-catalog.js

@@ -1,4 +1,12 @@
 // Bounded progressive-disclosure catalog for Capsules visible to a Mate.
+//
+// Skills are gated by Display: a Capsule the human cannot operate by hand is a
+// Capsule no Mate may reach either, so an entry appears here only while its
+// declarative Display floor validates. The gate reads the Capsule's own tree,
+// carried alongside each manifest, and fails closed on a scan error, a missing
+// ID, or a missing or invalid Display.
+
+var capsuleFloor = require("./capsule-display-floor");
 
 var MAX_NAME_LENGTH = 80;
 var MAX_DESCRIPTION_LENGTH = 240;
@@ -35,7 +43,7 @@ function discoveryEntry(manifest) {
 function buildCapsuleCatalogPrompt(manifests) {
   if (!Array.isArray(manifests) || manifests.length === 0) return "";
   var sorted = manifests.filter(function (manifest) {
-    return manifest && !manifest.error && manifest.id;
+    return capsuleFloor.hasUsableFloor(manifest);
   }).slice().sort(function (a, b) {
     var first = String(a.id);
     var second = String(b.id);

package/lib/project-capsule-turn.js

@@ -0,0 +1,96 @@
+// Delivers a Capsule turn prompt into this Mate project.
+//
+// A Capsule game against a Mate needs the Mate to actually take its turns:
+// when Logic passes the turn to the mate seat, this module wakes the Mate
+// with a prompt telling it to snapshot the game and act. One session hosts
+// the whole game (found again by session.capsuleGame.toolId), so the user
+// watches a single running conversation of the Mate playing rather than a
+// new session per turn. The prompt is recorded as an internal user message,
+// the same shape the debate engine uses, so the transcript shows the nudge
+// without pretending the human typed it.
+//
+// This module only carries words to the Mate. Every actual game mutation the
+// Mate then makes goes through the same clay_tool_act pipeline as always.
+
+function attachCapsuleTurn(ctx) {
+  var sm = ctx.sm;
+
+  function ownsSession(session, principal) {
+    if (ctx.isMultiUser()) return !!principal.userId && session.ownerId === principal.userId;
+    return !session.ownerId;
+  }
+
+  function findGameSession(principal, toolId) {
+    var found = null;
+    sm.sessions.forEach(function (session) {
+      if (found || !session || session.hidden || session.destroying) return;
+      if (!session.capsuleGame || session.capsuleGame.toolId !== toolId) return;
+      if (!ownsSession(session, principal)) return;
+      found = session;
+    });
+    return found;
+  }
+
+  async function createGameSession(principal, options) {
+    var selection = await ctx.resolveModel(principal);
+    if (!selection || selection.status !== "ready" || !selection.vendor || !selection.model) {
+      throw new Error(selection && selection.error ? selection.error : "No configured model is available for the Mate.");
+    }
+    var create = typeof sm.createSessionRaw === "function" ? sm.createSessionRaw : sm.createSession;
+    var session = create.call(sm, {
+      ownerId: principal.userId || null,
+      vendor: selection.vendor,
+      model: selection.model,
+    });
+    session.title = (options.toolName || options.toolId) + " game";
+    session.capsuleGame = { toolId: options.toolId };
+    return session;
+  }
+
+  async function deliverCapsuleTurn(principal, options) {
+    if (!principal || !options || !options.toolId || !options.text) {
+      throw new Error("A bound owner, toolId, and turn text are required.");
+    }
+    var sdk = ctx.getSdk();
+    if (!sdk || typeof sdk.startQuery !== "function") throw new Error("Mate project runtime is unavailable.");
+    var session = findGameSession(principal, options.toolId);
+    var created = false;
+    if (!session) {
+      session = await createGameSession(principal, options);
+      created = true;
+    }
+    // Recorded as a dedicated event, not a user message: the transcript shows
+    // a short system note (see historyToHomeChat) instead of pretending the
+    // human typed the delivery prompt. The full prompt still reaches the
+    // model through the query below.
+    sm.sendAndRecord(session, {
+      type: "capsule_turn",
+      text: options.text,
+      toolId: options.toolId,
+      toolName: options.toolName || options.toolId,
+      kind: options.kind || "turn",
+    });
+    session.isProcessing = true;
+    session.lastActivity = Date.now();
+    sm.broadcastSessionList();
+    try {
+      var delivered = typeof sdk.pushMessage === "function" ? sdk.pushMessage(session, options.text) : false;
+      if (!delivered) await Promise.resolve(sdk.startQuery(session, options.text, undefined, ctx.getLinuxUserForSession(session)));
+    } catch (error) {
+      session.isProcessing = false;
+      sm.sendAndRecord(session, { type: "error", text: "Capsule turn could not start: " + (error && error.message ? error.message : String(error)) });
+      sm.broadcastSessionList();
+      throw error;
+    }
+    // The reference shape the home chat surface opens sessions by.
+    return {
+      session: session,
+      created: created,
+      reference: (typeof session.cliSessionId === "string" && session.cliSessionId) || "local:" + session.localId,
+    };
+  }
+
+  return { deliverCapsuleTurn: deliverCapsuleTurn };
+}
+
+module.exports = { attachCapsuleTurn: attachCapsuleTurn };

package/lib/project-connection.js

@@ -233,7 +233,7 @@ function attachConnection(ctx) {
     // so vendor badges showed Claude until the next broadcast).
     sendTo(ws, {
       type: "session_list",
-      sessions: allSessions.map(function (s) { return sm.mapSessionForClient(s); }),
+      sessions: sm.mapSessionsForClient(allSessions),
     });
     if (_splitGroups) _splitGroups.sendConnectionState(ws);
 
@@ -350,9 +350,22 @@ function attachConnection(ctx) {
     broadcastPresence();
   }
 
+  // Keep-alive for the project socket, mirroring the `/ws` global handler.
+  //
+  // A reverse proxy resets its upstream read timeout on data flowing back from
+  // the server, so a client ping is only useful if the server answers it. This
+  // reads nothing, mutates nothing, and reveals nothing about the connection:
+  // it is a fixed reply on a fixed message type.
+  function handleKeepaliveMessage(ws, msg) {
+    if (!msg || typeof msg !== "object" || msg.type !== "ping") return false;
+    sendTo(ws, { type: "pong" });
+    return true;
+  }
+
   return {
     handleConnection: handleConnection,
     handleDisconnection: handleDisconnection,
+    handleKeepaliveMessage: handleKeepaliveMessage,
   };
 }
 

package/lib/project-http.js

@@ -730,7 +730,7 @@ function attachHTTP(ctx) {
     }
 
     // Git panel status and actions
-    var isGitPanelRequest = urlPath === "/api/git/status" ||
+    var isGitPanelRequest = urlPath === "/api/git/status" || urlPath === "/api/git/summary" ||
       urlPath === "/api/git/action" || urlPath.indexOf("/api/git/file-diff?") === 0 ||
       urlPath.indexOf("/api/git/session-diff?") === 0;
     if (isGitPanelRequest && usersModule.isMultiUser()) {
@@ -768,6 +768,20 @@ function attachHTTP(ctx) {
       return true;
     }
 
+    // Compact repository placard data for the always-visible sidebar block.
+    // Same permission gate as the panel, but no file payload and no path.
+    if (req.method === "GET" && urlPath === "/api/git/summary") {
+      try {
+        var gitSummary = gitCli.getSummary(cwd, getOsUserInfoForReq(req));
+        res.writeHead(200, { "Content-Type": "application/json", "Cache-Control": "no-store" });
+        res.end(JSON.stringify(gitSummary));
+      } catch (e) {
+        res.writeHead(500, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: e.message || "Unable to read Git summary" }));
+      }
+      return true;
+    }
+
     if (req.method === "GET" && urlPath.indexOf("/api/git/file-diff?") === 0) {
       var gitDiffParams = new URLSearchParams(urlPath.slice(urlPath.indexOf("?")));
       var gitDiffPath = gitDiffParams.get("path");

package/lib/project-knowledge.js

@@ -1,5 +1,6 @@
 var fs = require("fs");
 var path = require("path");
+var mateSync = require("./mate-knowledge-sync");
 
 /**
  * Attach knowledge file management to a project context.
@@ -75,6 +76,23 @@ function attachKnowledge(ctx) {
     return files;
   }
 
+  // Mirror a Mate-owned knowledge file into the Clay-wide Knowledge backend
+  // after the legacy write has already succeeded. The legacy file stays
+  // authoritative; this only keeps the new scope from going stale.
+  function mirrorMateSource(ws, fileName) {
+    if (!isMate) return;
+    var user = (ws && ws._clayUser) || null;
+    mateSync.syncQuietly({
+      mateDir: cwd,
+      fileName: fileName,
+      actor: {
+        type: user ? "user" : "system",
+        userId: user ? user.id : null,
+        displayName: user ? (user.displayName || user.username) : null,
+      },
+    });
+  }
+
   function handleKnowledgeMessage(ws, msg) {
     if (msg.type === "knowledge_list") {
       sendTo(ws, { type: "knowledge_list", files: listKnowledgeFiles() });
@@ -111,6 +129,7 @@ function attachKnowledge(ctx) {
       var knowledgeDir = path.join(cwd, "knowledge");
       fs.mkdirSync(knowledgeDir, { recursive: true });
       fs.writeFileSync(path.join(knowledgeDir, safeName), msg.content);
+      mirrorMateSource(ws, safeName);
       sendTo(ws, { type: "knowledge_saved", name: safeName });
       sendTo(ws, { type: "knowledge_list", files: listKnowledgeFilesBasic() });
       return true;
@@ -121,6 +140,9 @@ function attachKnowledge(ctx) {
       var safeName = path.basename(msg.name);
       var filePath = path.join(cwd, "knowledge", safeName);
       try { fs.unlinkSync(filePath); } catch (e) {}
+      // Reconciling after the unlink appends a tombstone, so a deleted file
+      // does not stay live in the new backend.
+      mirrorMateSource(ws, safeName);
       sendTo(ws, { type: "knowledge_deleted", name: safeName });
       sendTo(ws, { type: "knowledge_list", files: listKnowledgeFilesBasic() });
       return true;

package/lib/project-log-context.js

@@ -0,0 +1,172 @@
+// Stable project knowledge and Git worktree change-set identities.
+//
+// Existing projects freeze their current path-derived scope so every opaque
+// log ref remains valid. New projects receive a path-independent id. A linked
+// worktree stores its generated change-set marker in Git's administrative
+// directory, which survives daemon restarts and branch renames but disappears
+// with the worktree itself; the durable log records retain the id afterward.
+
+var crypto = require("crypto");
+var fs = require("fs");
+var path = require("path");
+var { runGitSync } = require("./git-cli");
+var { fsAsUser } = require("./os-users");
+var logsRoot = require("./project-logs-root");
+var utils = require("./utils");
+
+var ID_PATTERN = /^[A-Za-z0-9_-]{1,120}$/;
+
+function newId(prefix) {
+  return prefix + "_" + crypto.randomBytes(16).toString("base64url");
+}
+
+function validId(value, prefix) {
+  return typeof value === "string" && ID_PATTERN.test(value) && (!prefix || value.indexOf(prefix + "_") === 0);
+}
+
+function legacyKnowledgeId(cwd) {
+  return utils.encodeCwd(logsRoot.resolveProjectRoot(cwd));
+}
+
+function ensureProjectKnowledgeId(project) {
+  if (!project || typeof project !== "object") return false;
+  if (validId(project.projectKnowledgeId)) return false;
+  project.projectKnowledgeId = project.path ? legacyKnowledgeId(project.path) : newId("pk");
+  return true;
+}
+
+function initializeProjectKnowledge(config) {
+  var changed = false;
+  var projects = config && Array.isArray(config.projects) ? config.projects : [];
+  for (var i = 0; i < projects.length; i++) {
+    if (ensureProjectKnowledgeId(projects[i])) changed = true;
+  }
+  return changed;
+}
+
+function createProjectKnowledgeId() {
+  return newId("pk");
+}
+
+function git(cwd, args, osUserInfo) {
+  return runGitSync(cwd, args, null, osUserInfo).trim();
+}
+
+function commit(cwd, ref, osUserInfo) {
+  try { return git(cwd, ["rev-parse", ref || "HEAD"], osUserInfo); }
+  catch (e) { return null; }
+}
+
+function markerPath(cwd, osUserInfo) {
+  try {
+    var gitDir = git(cwd, ["rev-parse", "--git-dir"], osUserInfo);
+    return path.join(path.resolve(cwd, gitDir), "clay-change-set.json");
+  } catch (e) {
+    return null;
+  }
+}
+
+function readMarker(filePath, knowledgeId) {
+  if (!filePath) return null;
+  try {
+    var parsed = JSON.parse(fs.readFileSync(filePath, "utf8"));
+    if (!parsed || parsed.projectKnowledgeId !== knowledgeId || !validId(parsed.changeSetId, "cs")) return null;
+    return parsed;
+  } catch (e) {
+    return null;
+  }
+}
+
+function deterministicFallback(knowledgeId, cwd) {
+  var digest = crypto.createHash("sha256").update(knowledgeId + "\u0000" + logsRoot.canonicalPath(cwd)).digest("base64url");
+  return "cs_" + digest.substring(0, 22);
+}
+
+function writeMarker(filePath, marker, osUserInfo) {
+  var content = JSON.stringify(marker, null, 2) + "\n";
+  if (osUserInfo) {
+    fsAsUser("write", { file: filePath, content: content, flag: "wx", mode: 0o600 }, osUserInfo);
+    return;
+  }
+  fs.writeFileSync(filePath, content, { flag: "wx", mode: 0o600 });
+}
+
+function resolveWorktreeContext(cwd, knowledgeId, details, osUserInfo) {
+  var input = details || {};
+  var filePath = markerPath(cwd, osUserInfo);
+  var marker = readMarker(filePath, knowledgeId);
+  if (!marker) {
+    marker = {
+      projectKnowledgeId: knowledgeId,
+      changeSetId: newId("cs"),
+      baseCommit: input.baseCommit || null,
+      createdAt: Date.now(),
+    };
+    if (filePath) {
+      try {
+        writeMarker(filePath, marker, osUserInfo);
+      } catch (e) {
+        marker = readMarker(filePath, knowledgeId) || marker;
+      }
+    }
+  }
+  if (!filePath || !readMarker(filePath, knowledgeId)) {
+    marker.changeSetId = deterministicFallback(knowledgeId, cwd);
+  }
+  return {
+    kind: "worktree",
+    changeSetId: marker.changeSetId,
+    branch: input.branch || null,
+    baseCommit: marker.baseCommit || input.baseCommit || null,
+    headCommit: commit(cwd, "HEAD", osUserInfo),
+    status: "active",
+  };
+}
+
+function isMerged(parentCwd, worktreeCwd, osUserInfo) {
+  var head = commit(worktreeCwd, "HEAD", osUserInfo);
+  if (!head) return false;
+  try {
+    runGitSync(parentCwd, ["merge-base", "--is-ancestor", head, "HEAD"], null, osUserInfo);
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
+function cleanCommit(value) {
+  return typeof value === "string" && /^[0-9a-f]{7,64}$/i.test(value) ? value : null;
+}
+
+function cleanBranch(value) {
+  if (typeof value !== "string") return null;
+  var cleaned = value.trim().substring(0, 200);
+  return cleaned && cleaned.indexOf("\n") === -1 && cleaned.indexOf("\r") === -1 ? cleaned : null;
+}
+
+function normalizeRecordContext(value) {
+  if (!value || value.kind !== "worktree" || !validId(value.changeSetId, "cs")) {
+    return { kind: "project", changeSetId: null, branch: null, baseCommit: null, headCommit: null, status: "active" };
+  }
+  return {
+    kind: "worktree",
+    changeSetId: value.changeSetId,
+    branch: cleanBranch(value.branch),
+    baseCommit: cleanCommit(value.baseCommit),
+    headCommit: cleanCommit(value.headCommit),
+    status: value.status === "merged" || value.status === "archived" ? value.status : "active",
+  };
+}
+
+module.exports = {
+  ID_PATTERN: ID_PATTERN,
+  validId: validId,
+  legacyKnowledgeId: legacyKnowledgeId,
+  ensureProjectKnowledgeId: ensureProjectKnowledgeId,
+  initializeProjectKnowledge: initializeProjectKnowledge,
+  createProjectKnowledgeId: createProjectKnowledgeId,
+  resolveWorktreeContext: resolveWorktreeContext,
+  commit: commit,
+  isMerged: isMerged,
+  normalizeRecordContext: normalizeRecordContext,
+};

package/lib/project-log-feedback-delivery.js

@@ -0,0 +1,118 @@
+// Deliver new Project Log comments to the session responsible for the
+// canonical entry. A busy Driver gets an isolated hidden reviewer so feedback
+// never waits behind unrelated work in the visible conversation.
+
+function attachProjectLogFeedbackDelivery(ctx) {
+  var sm = ctx.sm;
+  var getSdk = ctx.getSdk;
+  var onProcessingChanged = ctx.onProcessingChanged || function () {};
+  var getLinuxUserForSession = ctx.getLinuxUserForSession || function () { return null; };
+
+  function sessionForAuthor(author) {
+    if (!author || author.type !== "session" || !author.sessionKey) return null;
+    var match = null;
+    sm.sessions.forEach(function (session) {
+      if (match || !session || session.destroying || session.hidden) return;
+      if (session.cliSessionId !== author.sessionKey && "local:" + session.localId !== author.sessionKey) return;
+      if ((session.ownerId || null) !== (author.userId || null)) return;
+      if (sm.sessions.get(session.localId) !== session) return;
+      match = session;
+    });
+    return match;
+  }
+
+  function findAuthorSession(entry) {
+    return sessionForAuthor(entry && entry.updatedBy) || sessionForAuthor(entry && entry.createdBy);
+  }
+
+  function startImmediateReviewer(source, entry, text, sdk) {
+    if (!sm.createSessionRaw || !sm.deleteSessionQuiet) return false;
+    var reviewer = sm.createSessionRaw({
+      ownerId: source.ownerId || null,
+      sessionVisibility: "private",
+      vendor: source.vendor || null,
+      model: source.model || null,
+      effort: source.effort || null,
+      permissionMode: source.permissionMode || null,
+    });
+    reviewer.hidden = true;
+    reviewer.title = "Project Log review";
+    reviewer.singleTurn = true;
+    reviewer.projectLogReview = { ref: entry.ref };
+    reviewer.isProcessing = true;
+    reviewer.sentToolResults = {};
+    reviewer.onQueryComplete = function () {
+      setImmediate(function () { sm.deleteSessionQuiet(reviewer.localId); });
+    };
+    sm.sendAndRecord(reviewer, {
+      type: "user_message",
+      text: text,
+      _internal: true,
+      projectLogFeedback: true,
+      projectLogRef: entry.ref,
+    });
+    Promise.resolve(sdk.startQuery(reviewer, text, null, getLinuxUserForSession(reviewer))).catch(function (error) {
+      reviewer.isProcessing = false;
+      sm.sendAndRecord(reviewer, {
+        type: "error",
+        text: "Could not review Project Log feedback: " + (error.message || String(error)),
+        _internal: true,
+      });
+      sm.deleteSessionQuiet(reviewer.localId);
+    });
+    return true;
+  }
+
+  function feedbackPrompt(entry) {
+    return "[Project Log feedback]\n" +
+      "A user added a comment to " + entry.ref + ". Review the pending feedback now with list_log_feedback, " +
+      "then resolve this specific comment through review_log_comment. Apply supported corrections to the canonical " +
+      "entry; otherwise clarify or decline with a concise reason. Do not treat this internal notification as user " +
+      "chat or answer it only in the conversation.\n" +
+      "[End Project Log feedback]";
+  }
+
+  function deliver(entry) {
+    if (!entry || !entry.ref || !entry.pendingFeedbackCount) return false;
+    var session = findAuthorSession(entry);
+    var sdk = getSdk();
+    if (!session || !sdk) return false;
+    var text = feedbackPrompt(entry);
+    if (session.isProcessing && startImmediateReviewer(session, entry, text, sdk)) return true;
+    sm.sendAndRecord(session, {
+      type: "user_message",
+      text: text,
+      _internal: true,
+      projectLogFeedback: true,
+      projectLogRef: entry.ref,
+    });
+    session.lastActivity = Date.now();
+    if (!session.isProcessing) {
+      session.isProcessing = true;
+      session.sentToolResults = {};
+      onProcessingChanged();
+      sm.sendToSession(session, { type: "status", status: "processing" });
+    }
+    if (!sdk.pushMessage(session, text)) {
+      session._queryStartTs = Date.now();
+      Promise.resolve(sdk.startQuery(session, text, null, getLinuxUserForSession(session))).catch(function (error) {
+        session.isProcessing = false;
+        sm.sendAndRecord(session, {
+          type: "error",
+          text: "Could not deliver Project Log feedback: " + (error.message || String(error)),
+          _internal: true,
+        });
+        onProcessingChanged();
+      });
+    }
+    sm.broadcastSessionList();
+    return true;
+  }
+
+  return {
+    deliver: deliver,
+    findAuthorSession: findAuthorSession,
+  };
+}
+
+module.exports = { attachProjectLogFeedbackDelivery: attachProjectLogFeedbackDelivery };