clay-server 4.0.0-beta.1 → 4.0.0-beta.11

package/lib/sdk-bridge.js

@@ -128,6 +128,9 @@ function createSDKBridge(opts) {
   var clayTls = opts.clayTls || false;
   var clayAuthToken = opts.clayAuthToken || null;
   var getSessionToolDefs = opts.getSessionToolDefs || function () { return []; };
+  // Split Worker permission routing. A getter because the pair module is
+  // constructed before this bridge exists.
+  var getWorkerPermissionRouter = opts.getWorkerPermissionRouter || function () { return null; };
   var onProcessingChanged = opts.onProcessingChanged || function () {};
   var _cachedFreshAuthState = null;
   var _cachedFreshAuthAt = 0;
@@ -601,18 +604,53 @@ function createSDKBridge(opts) {
       return { behavior: "allow", updatedInput: input };
     }
 
-    // Auto-approve split-pair partner tools. The pair itself is
-    // user-constructed (the user created the split and its roles and
-    // watches both panes live), the target is structurally confined to the
-    // split partner, and a prompt on every delegation hop defeats the
-    // driver/worker workflow. spawn_sessions is NOT here: it creates new
-    // sessions and keeps its prompt.
-    var pairPartnerTools = { send_to_partner: true, read_partner: true, propose_worker: true };
-    if (toolName.indexOf("mcp__clay-sessions__") === 0) {
-      var sessionsToolName = toolName.substring(toolName.lastIndexOf("__") + 2);
-      if (pairPartnerTools[sessionsToolName]) {
+    // Auto-approve the visible Driver/Split Worker pair tools, including the
+    // Driver's answer to a Worker permission request. The pair is
+    // user-constructed and both panes are on screen; every one of these tools
+    // is structurally confined to the caller's own exact pair and re-checks
+    // Driver eligibility, ownership and the live pair inside its handler, so
+    // the whitelist grants no authority the handler would not already demand.
+    // A prompt on each hop would reinstate exactly the approval gate the
+    // autonomous lifecycle exists to remove.
+    //
+    // spawn_sessions is deliberately absent: it creates arbitrary sessions.
+    //
+    // Only the two name forms the bridge can genuinely emit are accepted:
+    //
+    //   mcp__clay-sessions__<tool>  every MCP-mounted vendor. The server
+    //                              segment is matched exactly, so a tool of
+    //                              the same name on another MCP server is
+    //                              never auto-approved.
+    //   <tool>                      a Codex dynamic tool. Codex canonicalizes
+    //                              send_to_partner and read_partner to the MCP
+    //                              form itself, so only the remaining names
+    //                              can legitimately arrive bare.
+    var PAIR_MCP_PREFIX = "mcp__clay-sessions__";
+    var pairMcpTools = {
+      send_to_partner: true,
+      read_partner: true,
+      partner_status: true,
+      replace_partner: true,
+      interrupt_partner: true,
+      close_partner: true,
+      record_partner_evaluation: true,
+      respond_to_worker_permission: true,
+    };
+    var pairDynamicTools = {
+      partner_status: true,
+      replace_partner: true,
+      interrupt_partner: true,
+      close_partner: true,
+      record_partner_evaluation: true,
+      respond_to_worker_permission: true,
+    };
+    if (toolName.indexOf("mcp__") === 0) {
+      if (toolName.indexOf(PAIR_MCP_PREFIX) === 0
+          && pairMcpTools[toolName.slice(PAIR_MCP_PREFIX.length)]) {
         return { behavior: "allow", updatedInput: input };
       }
+    } else if (pairDynamicTools[toolName]) {
+      return { behavior: "allow", updatedInput: input };
     }
 
     // Sticky-note reads and writes are immediately visible on the shared
@@ -720,6 +758,19 @@ function createSDKBridge(opts) {
     // Full-auto mode: auto-approve everything except AskUserQuestion
     // (which still needs to go through the user interaction flow).
     var clayPermissionMode = session.permissionMode || sm.currentPermissionMode;
+    // A configured Split Worker is Driver-operated, so it runs under its
+    // Driver's permission mode, re-resolved from the live pair on every single
+    // decision. Nothing is copied at creation and the Worker's own persisted
+    // setting is never written, so toggling skip permissions on the Driver
+    // applies to the Worker's next call in either direction, mid-turn included.
+    var _wpMode = getWorkerPermissionRouter();
+    if (_wpMode && typeof _wpMode.inheritedPermissionMode === "function") {
+      var inherited = _wpMode.inheritedPermissionMode(session);
+      if (inherited) clayPermissionMode = inherited;
+    }
+    // AskUserQuestion is genuine user input, not an authorization, so it is
+    // excluded here exactly as it always was: a Driver in skip mode still
+    // cannot silently answer a question addressed to the person.
     if (clayPermissionMode === "bypassPermissions" && toolName !== "AskUserQuestion") {
       return Promise.resolve({ behavior: "allow", updatedInput: input });
     }
@@ -747,6 +798,22 @@ function createSDKBridge(opts) {
       return Promise.resolve({ behavior: "allow", updatedInput: input });
     }
 
+    // A visible Split Worker's remaining prompts belong to its paired Driver,
+    // not to the Worker pane. This sits below every auto-decision above, so
+    // skip permissions, the whitelist, allowedTools and the loop/debate
+    // policies all still resolve first and never wait on a Driver.
+    var _wp = getWorkerPermissionRouter();
+    if (_wp) {
+      var routed = _wp.routeIfWorker(session, {
+        toolName: toolName,
+        input: input,
+        toolUseId: opts.toolUseID,
+        decisionReason: opts.decisionReason || "",
+        signal: opts.signal,
+      });
+      if (routed) return routed;
+    }
+
     // Regular tool permission request: send to client and wait
     return new Promise(function(resolve) {
       var requestId = crypto.randomUUID();

package/lib/sdk-message-processor.js

@@ -1,5 +1,6 @@
 var usersModule = require("./users");
 var yoke = require("./yoke");
+var backgroundTaskTiming = require("./background-task-timing");
 
 function attachMessageProcessor(ctx) {
   var sm = ctx.sm;
@@ -60,6 +61,8 @@ function attachMessageProcessor(ctx) {
     if (session._lastAuthEmit && (now - session._lastAuthEmit) < 5000) return;
     session._lastAuthEmit = now;
 
+    var vendor = session.vendor || "claude";
+
     var authUser = session.ownerId ? usersModule.findUserById(session.ownerId) : null;
     var authLinuxUser = authUser && authUser.linuxUser ? authUser.linuxUser : null;
     var canAutoLogin = !usersModule.isMultiUser()
@@ -69,10 +72,13 @@ function attachMessageProcessor(ctx) {
     var authTitle = ((vendorInfo && vendorInfo.displayName) || "Claude Code") + " is not logged in.";
     var loginCommand = (vendorInfo && vendorInfo.loginCommand) || "claude login";
     var _nmLogin = getNotificationsModule();
-    sendAndRecord(session, {
+    // Authentication recovery is transient UI state, not transcript content.
+    // Recording it makes history replay look like a fresh auth failure and
+    // re-opens the login terminal after a successful sign-in.
+    sendToSession(session, {
       type: "auth_required",
       text: authTitle,
-      vendor: session.vendor || "claude",
+      vendor: vendor,
       loginCommand: loginCommand,
       linuxUser: authLinuxUser,
       canAutoLogin: canAutoLogin,
@@ -84,7 +90,7 @@ function attachMessageProcessor(ctx) {
         slug: slug,
         sessionId: session.localId,
         ownerId: session.ownerId || null,
-        vendor: session.vendor || "claude",
+        vendor: vendor,
         loginCommand: loginCommand,
         linuxUser: authLinuxUser,
         canAutoLogin: canAutoLogin,
@@ -192,7 +198,9 @@ function attachMessageProcessor(ctx) {
 
     // Cache slash_commands and model from CLI init message
     if (parsed.yokeType === "init") {
-      var previousBackgroundTaskCount = (session.activeBackgroundTasks || []).length;
+      // Ambient housekeeping never drove the sidebar badge, so a reset that
+      // only clears ambient watchers must not rebroadcast the session list.
+      var previousBackgroundTaskCount = backgroundTaskTiming.countUserTasks(session.activeBackgroundTasks);
       session.activeBackgroundTasks = [];
       sendToSession(session, { type: "active_background_tasks", tasks: [] });
       if (previousBackgroundTaskCount !== 0) sm.broadcastSessionList();
@@ -686,11 +694,20 @@ function attachMessageProcessor(ctx) {
       }
 
     } else if (parsed.yokeType === "background_tasks_changed") {
-      var previousBackgroundTaskCount = (session.activeBackgroundTasks || []).length;
-      var activeBackgroundTasks = Array.isArray(parsed.tasks) ? parsed.tasks : [];
+      var previousBackgroundTasks = session.activeBackgroundTasks || [];
+      // Count user work only: an ambient watcher starting or stopping must not
+      // rebroadcast the session list and flicker every client's sidebar badge.
+      var previousBackgroundTaskCount = backgroundTaskTiming.countUserTasks(previousBackgroundTasks);
+      // Vendors re-send the whole list on every change, so carry each task's
+      // first-seen time forward; otherwise the composer's elapsed timer would
+      // restart whenever any other task starts or finishes.
+      var activeBackgroundTasks = backgroundTaskTiming.mergeStartTimes(
+        previousBackgroundTasks,
+        Array.isArray(parsed.tasks) ? parsed.tasks : []
+      );
       session.activeBackgroundTasks = activeBackgroundTasks;
       sendToSession(session, { type: "active_background_tasks", tasks: activeBackgroundTasks });
-      if (previousBackgroundTaskCount !== activeBackgroundTasks.length) {
+      if (previousBackgroundTaskCount !== backgroundTaskTiming.countUserTasks(activeBackgroundTasks)) {
         sm.broadcastSessionList();
       }
 

package/lib/server.js

@@ -23,6 +23,8 @@ var serverPalette = require("./server-palette");
 var workspaceQueryModule = require("./workspace-query-service");
 var { attachWorkspaceQueryService } = workspaceQueryModule;
 var { attachWorkspaceAssignmentService } = require("./workspace-assignment-service");
+var { attachProjectLogsService } = require("./project-logs-service");
+var { attachMateKnowledgeService } = require("./mate-knowledge-service");
 var serverEmail = require("./server-email");
 var serverGlobalWs = require("./server-global-ws");
 var { parseWsRequestUrl } = require("./ws-request");
@@ -306,18 +308,50 @@ function createServer(opts) {
   var workspaceQueryService = attachWorkspaceQueryService({
     getProjects: function () { return projects; },
     isMultiUser: function () { return users.isMultiUser(); },
-    canAccessProject: function (userId, status) {
-      return users.canAccessProject(userId, {
-        ownerId: status && status.projectOwnerId || null,
-        visibility: status && status.visibility || "public",
-        allowedUsers: status && status.allowedUsers || [],
-      });
+    // Project access is resolved from the authoritative project record, not
+    // from getStatus(), which carries no visibility or allowedUsers fields and
+    // would otherwise default every project to public.
+    onGetProjectAccess: onGetProjectAccess,
+    canAccessProject: function (userId, access) {
+      return users.canAccessProject(userId, access) === true;
     },
     resolveMate: function (userId, mateId) {
       return mates.getMate(mates.buildMateCtx(users.isMultiUser() ? userId : null), mateId);
     },
     assignmentService: assignmentService,
   });
+  // Project access is resolved from the authoritative project record, not from
+  // getStatus(), which carries no visibility or allowedUsers fields.
+  var projectLogsService = attachProjectLogsService({
+    getProjects: function () { return projects; },
+    isMultiUser: function () { return users.isMultiUser(); },
+    canAccessProject: function (userId, status) {
+      if (!status || !status.slug || !onGetProjectAccess) return false;
+      var access = onGetProjectAccess(status.slug);
+      if (!access || access.error) return false;
+      return users.canAccessProject(userId, access) === true;
+    },
+    resolveMate: function (userId, mateId) {
+      return mates.getMate(mates.buildMateCtx(users.isMultiUser() ? userId : null), mateId);
+    },
+    findUserById: function (userId) { return users.findUserById(userId); },
+  });
+  // Mate Knowledge reads the synchronized Knowledge records. The Mate list is
+  // derived from the owning user alone, so a binding can never span users.
+  var mateKnowledgeService = attachMateKnowledgeService({
+    getProjects: function () { return projects; },
+    isMultiUser: function () { return users.isMultiUser(); },
+    resolveMate: function (userId, mateId) {
+      return mates.getMate(mates.buildMateCtx(users.isMultiUser() ? userId : null), mateId);
+    },
+    listMates: function (userId) {
+      var mateCtx = mates.buildMateCtx(users.isMultiUser() ? userId : null);
+      var all = mates.getAllMates(mateCtx) || [];
+      return all.map(function (mate) {
+        return { id: mate.id, name: mate.name || null, createdBy: mate.createdBy || null, dir: mates.getMateDir(mateCtx, mate.id) };
+      });
+    },
+  });
 
   // --- Admin module ---
   var admin = serverAdmin.attachAdmin({
@@ -1155,6 +1189,24 @@ function createServer(opts) {
   }
 
   // --- Project management ---
+  function refreshVendorAuthEverywhere(vendor, linuxUser) {
+    var refreshes = [];
+    projects.forEach(function (projectCtx) {
+      if (!projectCtx || typeof projectCtx.refreshVendorAuth !== "function") return;
+      try {
+        refreshes.push(Promise.resolve(projectCtx.refreshVendorAuth(vendor, linuxUser)).catch(function (err) {
+          console.error("[server] Cross-project " + vendor + " auth refresh failed:", err && err.message ? err.message : err);
+          return false;
+        }));
+      } catch (err) {
+        console.error("[server] Cross-project " + vendor + " auth refresh threw:", err && err.message ? err.message : err);
+      }
+    });
+    return Promise.all(refreshes).then(function (results) {
+      return results.some(function (refreshed) { return !!refreshed; });
+    });
+  }
+
   function addProject(cwd, slug, title, icon, projectOwnerId, worktreeMeta, extraOpts) {
     if (projects.has(slug)) return false;
     var extra = extraOpts || {};
@@ -1174,6 +1226,8 @@ function createServer(opts) {
         return mateHandler.createReadyMateFromInterview(ws, userId, definition);
       },
       workspaceQueryService: workspaceQueryService,
+      projectLogsService: projectLogsService,
+      mateKnowledgeService: mateKnowledgeService,
       getProjectAccess: function () {
         return onGetProjectAccess ? onGetProjectAccess(slug) : { visibility: "public", ownerId: projectOwnerId || null };
       },
@@ -1327,6 +1381,7 @@ function createServer(opts) {
       onDmMessage: handleDmMessage,
       broadcastAll: broadcastAll,
       notificationsModule: _globalNotifications,
+      refreshVendorAuthEverywhere: refreshVendorAuthEverywhere,
       getProject: function (s) { return projects.get(s) || null; },
       isUserOnline: isUserOnline,
     });

package/lib/session-driver-eligibility.js

@@ -0,0 +1,183 @@
+// Driver eligibility: which models may hold the Driver role of a visible
+// Driver/Split Worker pair and receive the autonomous lifecycle tools.
+//
+// There is no canonical tier helper in the repo to reuse. Claude models are
+// enumerated by the SDK at runtime, so there is no static list; Codex ships a
+// fixed catalog in yoke/adapters/codex.js. What both have in common is a tier
+// token in the model id and in its display name, which the existing
+// project-worker-proposal.js already keys on ("fable"). This module makes that
+// same idea explicit, ordered, and vendor-scoped.
+//
+// Ranks are per vendor family and are only ever compared within a family; no
+// cross-vendor ranking is implied or invented.
+//
+//   claude family   haiku 1  <  sonnet 2  <  opus 3  <  fable 4
+//                   real ids: claude-haiku-4-5-20251001, claude-sonnet-5,
+//                             claude-opus-5, claude-fable-5
+//                   Driver threshold: fable
+//
+//   codex family    gpt-5.2 1 < gpt-5.5 2 < luna 3 < sol 4 < terra 5
+//                   real ids: the CODEX_MODELS catalog, strongest first
+//                   Driver threshold: sol
+//
+// Matching is by token, not by exact id, so a later release in the same family
+// (claude-fable-6, gpt-5.7-terra) stays eligible without a code change. A
+// model in a known family whose tier token is unrecognized is NOT eligible:
+// unknown capability fails closed rather than inheriting the threshold.
+//
+// Any other vendor is not eligible for the Driver role at all, because no
+// equivalent tier metadata exists to compare against. Those vendors remain
+// perfectly usable as Workers.
+
+var models = require("./project-models");
+
+var FAMILIES = {
+  claude: {
+    label: "Claude",
+    threshold: 4,
+    thresholdName: "Fable",
+    // Longest/most specific tokens first so "haiku" cannot shadow a future
+    // compound name. Each entry is a token searched in id and display name.
+    tiers: [
+      { token: "fable", rank: 4, name: "Fable" },
+      { token: "opus", rank: 3, name: "Opus" },
+      { token: "sonnet", rank: 2, name: "Sonnet" },
+      { token: "haiku", rank: 1, name: "Haiku" },
+    ],
+  },
+  codex: {
+    label: "OpenAI",
+    threshold: 4,
+    thresholdName: "Sol",
+    tiers: [
+      { token: "terra", rank: 5, name: "Terra" },
+      { token: "sol", rank: 4, name: "Sol" },
+      { token: "luna", rank: 3, name: "Luna" },
+      { token: "gpt-5.5", rank: 2, name: "GPT-5.5" },
+      { token: "gpt-5.2", rank: 1, name: "GPT-5.2" },
+    ],
+  },
+};
+
+function familyFor(vendor) {
+  var key = String(vendor || "").toLowerCase();
+  return Object.prototype.hasOwnProperty.call(FAMILIES, key) ? FAMILIES[key] : null;
+}
+
+// Every string the catalog knows this model by. The catalog entry is found with
+// the repo's own matcher so an alias ("fable"), an id, or a resolvedModel all
+// resolve to the same entry, and the display name participates in tier
+// detection exactly as project-worker-proposal.js already relies on.
+function searchTextFor(vendor, model, modelsByVendor) {
+  var parts = [String(model || "")];
+  var catalog = (modelsByVendor && modelsByVendor[vendor]) || [];
+  for (var i = 0; i < catalog.length; i++) {
+    if (!models.modelEntryMatches(catalog[i], model)) continue;
+    var entry = catalog[i];
+    if (typeof entry === "string") {
+      parts.push(entry);
+    } else {
+      parts.push(entry.value || "");
+      parts.push(entry.id || "");
+      parts.push(entry.resolvedModel || "");
+      parts.push(entry.displayName || "");
+      parts.push(entry.name || "");
+    }
+    break;
+  }
+  return parts.join(" ").toLowerCase();
+}
+
+// Resolve the tier of one model inside its vendor family. Returns null when
+// the vendor has no tier metadata or the tier token is unrecognized.
+function resolveTier(vendor, model, modelsByVendor) {
+  var family = familyFor(vendor);
+  if (!family || !model) return null;
+  var text = searchTextFor(vendor, model, modelsByVendor);
+  for (var i = 0; i < family.tiers.length; i++) {
+    if (text.indexOf(family.tiers[i].token) !== -1) {
+      return {
+        vendor: String(vendor).toLowerCase(),
+        family: family.label,
+        rank: family.tiers[i].rank,
+        name: family.tiers[i].name,
+        threshold: family.threshold,
+        thresholdName: family.thresholdName,
+      };
+    }
+  }
+  return null;
+}
+
+// The hard invariant. Returns { ok, tier, error } and never throws. `error` is
+// a complete English sentence suitable for returning to a tool caller.
+function evaluateDriverModel(vendor, model, modelsByVendor) {
+  var family = familyFor(vendor);
+  if (!family) {
+    return {
+      ok: false,
+      tier: null,
+      error: "The Driver role requires a Claude model of Fable tier or higher, or an OpenAI model of " +
+        "Sol tier or higher. Vendor \"" + String(vendor || "unknown") + "\" has no comparable tier " +
+        "metadata, so it cannot take the Driver role. It can still be used for the Split Worker.",
+    };
+  }
+  if (!model) {
+    return {
+      ok: false,
+      tier: null,
+      error: "This session has no resolved model yet, so its " + family.label +
+        " tier cannot be confirmed. The Driver role requires " + family.thresholdName +
+        " tier or higher.",
+    };
+  }
+  var tier = resolveTier(vendor, model, modelsByVendor);
+  if (!tier) {
+    return {
+      ok: false,
+      tier: null,
+      error: "Model \"" + model + "\" is not a recognized " + family.label +
+        " tier, so it cannot take the Driver role. The Driver role requires " +
+        family.thresholdName + " tier or higher.",
+    };
+  }
+  if (tier.rank < tier.threshold) {
+    return {
+      ok: false,
+      tier: tier,
+      error: "The Driver role requires a " + family.label + " model of " + family.thresholdName +
+        " tier or higher. This session is " + tier.name + " tier.",
+    };
+  }
+  return { ok: true, tier: tier, error: null };
+}
+
+// The session-level form. Resolves the session's effective model the same way
+// the rest of the server does: the session's own model, else the vendor
+// default. Identity is read from the session object, never from a caller.
+function evaluateDriverSession(session, sm) {
+  if (!session) return { ok: false, tier: null, error: "No session was bound to this request." };
+  if (session.mode === "tui") {
+    return {
+      ok: false,
+      tier: null,
+      error: "An embedded terminal session cannot take the Driver role.",
+    };
+  }
+  var vendor = session.vendor || "claude";
+  var fallback = (sm && sm.defaultModelByVendor && sm.defaultModelByVendor[vendor]) || "";
+  var model = session.model || fallback;
+  return evaluateDriverModel(vendor, model, sm && sm.modelsByVendor);
+}
+
+function isEligibleDriverSession(session, sm) {
+  return evaluateDriverSession(session, sm).ok;
+}
+
+module.exports = {
+  FAMILIES: FAMILIES,
+  evaluateDriverModel: evaluateDriverModel,
+  evaluateDriverSession: evaluateDriverSession,
+  isEligibleDriverSession: isEligibleDriverSession,
+  resolveTier: resolveTier,
+};

package/lib/session-notes-mcp-server.js

@@ -9,14 +9,18 @@ var MEMORY_CONTRACT =
   "Important exception for deferred defects: while doing code or technical work, actively create a sticky note when you discover a concrete defect, regression risk, security issue, or data-loss risk that is outside the current session goal and will remain unfixed when the turn ends. Do not wait for the user to ask. Include the observable evidence, affected component, likely impact, and a clear next action. Check active notes first when a duplicate is plausible. Do not create defect notes for speculation, general cleanup ideas, or problems you fixed in the current session. " +
   "Important exception for deferred proposals: when you propose work (a fix, follow-up, improvement, or next step) and the user defers it rather than declining it (\"let's do that later\", \"next time\", \"after this\"), actively create a sticky note before the topic moves on. Do not wait to be asked. Capture what was proposed, why it mattered, and the agreed timing if any. Deferred agreements scroll out of chat history quickly and are hard to track; the board is where they survive. If the user declines the idea outright, do not write a note. " +
   "Never create a note merely because work is important, lengthy, spans agents or restarts, or might help another agent. Do not record completed work, implementation details, test results, investigation logs, transient blockers, conversation summaries, or announcements of your own activity. When uncertain, do not write. " +
-  "Updates are visible too: update only when durable state materially changes, and remove a note created by your session when it stops being useful instead of turning it into a completion log. Put a concise plain-text title on the first line, stay focused on one topic, and include only the context needed for future action.";
+  "Updates are visible too: update only when durable state materially changes. " +
+  "A note is an attention item, so finishing it means closing it, never erasing it: call close_note once the thing it is asking for is done, and the note leaves the active board while the record stays and can be reopened. Do not turn a note into a completion log instead of closing it. " +
+  "Put a concise plain-text title on the first line, stay focused on one topic, and include only the context needed for future action.";
 
 function getToolDefs(handlers) {
   return [
     {
       name: "list_notes",
-      description: MEMORY_CONTRACT + " List the active notes before writing when you need to avoid duplicates or inspect full memory beyond the injected summary.",
-      inputSchema: buildShape({}),
+      description: MEMORY_CONTRACT + " List the notes before writing when you need to avoid duplicates or inspect full memory beyond the injected summary. Lists open notes by default; pass state to see closed ones.",
+      inputSchema: buildShape({
+        state: { type: "string", enum: ["open", "closed", "all"], description: "Which notes to list. Defaults to open, the notes still asking for action." },
+      }),
       handler: function (args) { return handlers.list(args || {}); },
     },
     {
@@ -29,11 +33,27 @@ function getToolDefs(handlers) {
       }, ["text"]),
       handler: function (args) { return handlers.write(args || {}); },
     },
+    {
+      name: "close_note",
+      description: MEMORY_CONTRACT + " Close a note created by this same session once what it asked for is done. Closing is not deletion: the note leaves the active board, stays queryable under state closed, and can be reopened. Notes created by users or other sessions cannot be closed by this session.",
+      inputSchema: buildShape({
+        id: { type: "string", description: "Id of the note to close." },
+      }, ["id"]),
+      handler: function (args) { return handlers.close(args || {}); },
+    },
+    {
+      name: "reopen_note",
+      description: MEMORY_CONTRACT + " Reopen a closed note created by this same session when it turns out to still need action. The note returns to the active board unchanged.",
+      inputSchema: buildShape({
+        id: { type: "string", description: "Id of the note to reopen." },
+      }, ["id"]),
+      handler: function (args) { return handlers.reopen(args || {}); },
+    },
     {
       name: "remove_note",
-      description: MEMORY_CONTRACT + " Remove a note created by this same session when it is no longer true. Notes created by users or other sessions cannot be removed.",
+      description: MEMORY_CONTRACT + " Deprecated: use close_note. This tool no longer deletes anything and now closes the note instead, so an older caller cannot destroy a record. Same ownership rule as close_note.",
       inputSchema: buildShape({
-        id: { type: "string", description: "Id of the note to remove." },
+        id: { type: "string", description: "Id of the note to close. Nothing is deleted." },
       }, ["id"]),
       handler: function (args) { return handlers.remove(args || {}); },
     },