clay-server 2.23.0-beta.5 → 2.23.0-beta.7

package/lib/builtin-mates.js

@@ -8,15 +8,22 @@
 // ---------------------------------------------------------------------------
 
 var BUILTIN_MATES = [
-  // ---- ALLY ----
+  // ---- ALLY (primary mate: code-managed, auto-updated, non-deletable) ----
   {
     key: "ally",
     displayName: "Ally",
-    bio: "Chief of staff. Quiet, sharp, misses nothing. Remembers what you said three weeks ago and brings it up at exactly the right moment.",
+    bio: "Chief of staff. Quiet, sharp, sees across every mate. Knows what Arch decided yesterday, what Buzz pitched last week, and what you said three weeks ago.",
     avatarColor: "#00b894",
     avatarStyle: "bottts",
     avatarCustom: "/mates/ally.png",
     avatarLocked: true,
+    // --- Primary mate flags ---
+    // Primary mates are system infrastructure, not just pre-made mates.
+    // They are auto-synced with the latest code on every startup,
+    // cannot be deleted by users, and have elevated capabilities.
+    primary: true,           // code-managed, auto-updated on startup
+    globalSearch: true,      // searches all mates' sessions and projects
+    templateVersion: 3,      // v3: moved capabilities to dynamic system section
     seedData: {
       relationship: "assistant",
       activity: ["planning", "organizing"],
@@ -581,8 +588,21 @@ function getBuiltinKeys() {
   return keys;
 }
 
+/**
+ * Get all primary mate definitions.
+ * Primary mates are code-managed system agents (not just pre-made mates).
+ */
+function getPrimaryMates() {
+  var result = [];
+  for (var i = 0; i < BUILTIN_MATES.length; i++) {
+    if (BUILTIN_MATES[i].primary) result.push(BUILTIN_MATES[i]);
+  }
+  return result;
+}
+
 module.exports = {
   BUILTIN_MATES: BUILTIN_MATES,
   getBuiltinByKey: getBuiltinByKey,
   getBuiltinKeys: getBuiltinKeys,
+  getPrimaryMates: getPrimaryMates,
 };

package/lib/mates.js

@@ -134,11 +134,15 @@ function createMate(ctx, seedData) {
     claudeMd += "- Communication: " + seedData.communicationStyle.join(", ") + "\n";
   }
   claudeMd += "- Autonomy: " + (seedData.autonomy || "always_ask") + "\n";
+  var initialIdentity = claudeMd.trimEnd();
   claudeMd += TEAM_SECTION;
   claudeMd += SESSION_MEMORY_SECTION;
   claudeMd += crisisSafety.getSection();
   fs.writeFileSync(path.join(mateDir, "CLAUDE.md"), claudeMd);
 
+  // Log creation (identity is placeholder, will be replaced by interview)
+  logIdentityChange(mateDir, "create_custom", initialIdentity, "");
+
   return mate;
 }
 
@@ -154,6 +158,17 @@ function updateMate(ctx, id, updates) {
   var data = loadMates(ctx);
   for (var i = 0; i < data.mates.length; i++) {
     if (data.mates[i].id === id) {
+      // Primary mates: protect name and core identity fields
+      if (data.mates[i].primary) {
+        delete updates.name;
+        delete updates.bio;
+        delete updates.primary;
+        delete updates.globalSearch;
+        delete updates.templateVersion;
+        if (updates.profile) {
+          delete updates.profile.displayName;
+        }
+      }
       var keys = Object.keys(updates);
       for (var j = 0; j < keys.length; j++) {
         data.mates[i][keys[j]] = updates[keys[j]];
@@ -167,6 +182,12 @@ function updateMate(ctx, id, updates) {
 
 function deleteMate(ctx, id) {
   var data = loadMates(ctx);
+  // Primary mates cannot be deleted (they are system infrastructure)
+  for (var di = 0; di < data.mates.length; di++) {
+    if (data.mates[di].id === id && data.mates[di].primary) {
+      return { error: "Primary mates cannot be deleted. They are managed by the system." };
+    }
+  }
   var before = data.mates.length;
   data.mates = data.mates.filter(function (m) {
     return m.id !== id;
@@ -271,6 +292,7 @@ function migrateLegacyMates() {
 
 var TEAM_MARKER = "<!-- TEAM_AWARENESS_MANAGED_BY_SYSTEM -->";
 
+// Static fallback when ctx is unavailable
 var TEAM_SECTION =
   "\n\n" + TEAM_MARKER + "\n" +
   "## Your Team\n\n" +
@@ -283,6 +305,50 @@ var TEAM_SECTION =
   "Check the team registry when it would be relevant to know who else is available or what they do. " +
   "You cannot message other Mates directly yet, but knowing your team helps you work with the user more effectively.\n";
 
+/**
+ * Build a dynamic team section with current mate roster.
+ * Lists each teammate by stable ID with their current display name, role, and bio.
+ * @param {object} ctx - user context for loading mates
+ * @param {string} currentMateId - this mate's ID (excluded from the roster)
+ * @returns {string} Team section string, or static TEAM_SECTION as fallback
+ */
+function buildTeamSection(ctx, currentMateId) {
+  var data;
+  try { data = loadMates(ctx); } catch (e) { return TEAM_SECTION; }
+  if (!data || !data.mates || data.mates.length < 2) return TEAM_SECTION;
+
+  var mates = data.mates.filter(function (m) {
+    return m.id !== currentMateId && m.status === "ready";
+  });
+  if (mates.length === 0) return TEAM_SECTION;
+
+  var section = "\n\n" + TEAM_MARKER + "\n" +
+    "## Your Team\n\n" +
+    "**This section is managed by the system and updated automatically.**\n\n" +
+    "You are one of " + (mates.length + 1) + " AI Mates in this workspace. " +
+    "Here is your current team roster:\n\n" +
+    "| Name | ID | Bio |\n" +
+    "|------|-----|-----|\n";
+
+  for (var i = 0; i < mates.length; i++) {
+    var m = mates[i];
+    var name = (m.profile && m.profile.displayName) || m.name || "Unnamed";
+    var bio = (m.bio || "").replace(/\|/g, "/").replace(/\n/g, " ");
+    if (bio.length > 120) bio = bio.substring(0, 117) + "...";
+    section += "| " + name + " | `" + m.id + "` | " + bio + " |\n";
+  }
+
+  section += "\n" +
+    "Each teammate's full identity is in their own directory:\n\n" +
+    "- `../{mate_id}/CLAUDE.md` -- identity, personality, working style\n" +
+    "- `../{mate_id}/mate.yaml` -- metadata (name, role, status, activities)\n" +
+    "- `../common-knowledge.json` -- shared knowledge readable by all mates\n\n" +
+    "Use the **ID** (not the name) when referencing teammates in structured data. " +
+    "Names can change, IDs are permanent.\n";
+
+  return section;
+}
+
 // --- Project registry ---
 
 var PROJECT_REGISTRY_MARKER = "<!-- PROJECT_REGISTRY_MANAGED_BY_SYSTEM -->";
@@ -629,6 +695,210 @@ function enforceDebateAwareness(filePath) {
   return true;
 }
 
+// --- Primary mate capabilities (dynamically injected, never stored in identity) ---
+
+var PRIMARY_CAPABILITIES_MARKER = "<!-- PRIMARY_CAPABILITIES_MANAGED_BY_SYSTEM -->";
+
+/**
+ * Build the capabilities section for a primary mate.
+ * This is injected as a system section so it auto-updates with code changes
+ * without touching the mate's identity in CLAUDE.md.
+ */
+function buildPrimaryCapabilitiesSection(mate) {
+  if (!mate || !mate.primary) return "";
+
+  var parts = [
+    "\n\n" + PRIMARY_CAPABILITIES_MARKER,
+    "## System Capabilities",
+    "",
+    "**This section is managed by the system and updated automatically with each release.**",
+    ""
+  ];
+
+  if (mate.globalSearch) {
+    parts.push("### Cross-Mate Awareness");
+    parts.push("");
+    parts.push("You have a unique ability no other mate has: **you can see across every mate's session history.**");
+    parts.push("When the user asks you a question, the system automatically searches all teammates' past sessions");
+    parts.push("and surfaces relevant context to you. Results from other mates are tagged with their name (e.g. @Arch).");
+    parts.push("");
+    parts.push("Use this to:");
+    parts.push("- Answer questions like \"What did Arch decide about the API?\" or \"What was Buzz's take on the launch plan?\"");
+    parts.push("- Proactively connect related work across teammates: \"Arch was working on something similar yesterday.\"");
+    parts.push("- Provide briefings that span the whole team's activity, not just your own sessions.");
+    parts.push("");
+    parts.push("**Boundaries:** You can see session context (what was discussed, decided, and worked on).");
+    parts.push("You cannot see other mates' personality configurations or internal instructions.");
+    parts.push("");
+  }
+
+  return parts.join("\n");
+}
+
+// --- Atomic enforce: single read/write for all system sections ---
+
+var ALL_SYSTEM_MARKERS = [TEAM_MARKER, PROJECT_REGISTRY_MARKER, PRIMARY_CAPABILITIES_MARKER, SESSION_MEMORY_MARKER, STICKY_NOTES_MARKER, DEBATE_AWARENESS_MARKER, crisisSafety.MARKER];
+
+// Minimum identity length (chars) to consider it "real" content
+var IDENTITY_MIN_LENGTH = 50;
+
+/**
+ * Extract identity content from a CLAUDE.md string.
+ * Identity is everything before the first system marker.
+ */
+function extractIdentity(content) {
+  var earliest = -1;
+  for (var i = 0; i < ALL_SYSTEM_MARKERS.length; i++) {
+    var idx = content.indexOf(ALL_SYSTEM_MARKERS[i]);
+    if (idx !== -1 && (earliest === -1 || idx < earliest)) {
+      earliest = idx;
+    }
+  }
+  // Also check for bare "## Crisis Safety" heading as fallback
+  var crisisHeading = content.indexOf("\n## Crisis Safety");
+  if (crisisHeading !== -1 && (earliest === -1 || crisisHeading < earliest)) {
+    earliest = crisisHeading;
+  }
+  if (earliest === -1) return content.trimEnd();
+  return content.substring(0, earliest).trimEnd();
+}
+
+/**
+ * Strip all system sections from CLAUDE.md content, returning only identity.
+ */
+function stripAllSystemSections(content) {
+  return extractIdentity(content);
+}
+
+/**
+ * Save an identity backup to knowledge/identity-backup.md.
+ * Only overwrites if the new identity is substantive.
+ */
+function backupIdentity(mateDir, identity) {
+  if (!identity || identity.length < IDENTITY_MIN_LENGTH) return false;
+  var knDir = path.join(mateDir, "knowledge");
+  try { fs.mkdirSync(knDir, { recursive: true }); } catch (e) {}
+  var backupPath = path.join(knDir, "identity-backup.md");
+  fs.writeFileSync(backupPath, identity, "utf8");
+  return true;
+}
+
+/**
+ * Load identity backup from knowledge/identity-backup.md.
+ * Returns null if no backup exists or backup is empty.
+ */
+function loadIdentityBackup(mateDir) {
+  var backupPath = path.join(mateDir, "knowledge", "identity-backup.md");
+  try {
+    var content = fs.readFileSync(backupPath, "utf8");
+    if (content && content.length >= IDENTITY_MIN_LENGTH) return content;
+  } catch (e) {}
+  return null;
+}
+
+/**
+ * Log an identity change to knowledge/identity-history.jsonl.
+ */
+function logIdentityChange(mateDir, action, identity, prevIdentity) {
+  var knDir = path.join(mateDir, "knowledge");
+  try { fs.mkdirSync(knDir, { recursive: true }); } catch (e) {}
+  var historyPath = path.join(knDir, "identity-history.jsonl");
+  var entry = {
+    ts: Date.now(),
+    date: new Date().toISOString(),
+    action: action,
+    lengthChars: identity ? identity.length : 0,
+    prevLengthChars: prevIdentity ? prevIdentity.length : 0,
+    hash: crypto.createHash("sha256").update(identity || "").digest("hex").substring(0, 16),
+    preview: (identity || "").substring(0, 200)
+  };
+  try {
+    fs.appendFileSync(historyPath, JSON.stringify(entry) + "\n", "utf8");
+  } catch (e) {}
+}
+
+// Tracks paths we've already warned about missing identity (avoids log spam)
+var _warnedPaths = {};
+
+/**
+ * Atomic enforce: read CLAUDE.md once, enforce all system sections, write once.
+ * Includes identity backup, validation, and change tracking.
+ * Returns true if the file was modified, false if already correct.
+ * @param {string} filePath - path to CLAUDE.md
+ * @param {object} opts - optional { ctx, mateId } for dynamic team section
+ */
+function enforceAllSections(filePath, opts) {
+  if (!fs.existsSync(filePath)) return false;
+  opts = opts || {};
+
+  var content = fs.readFileSync(filePath, "utf8");
+  var mateDir = path.dirname(filePath);
+
+  // 1. Extract current identity (everything before system markers)
+  var identity = extractIdentity(content);
+  var identityMissing = !identity || identity.length < IDENTITY_MIN_LENGTH;
+
+  // 2. If identity is empty or suspiciously short, try to restore from backup
+  if (identityMissing) {
+    var backup = loadIdentityBackup(mateDir);
+    if (backup) {
+      console.log("[mates] Restoring identity from backup: " + filePath + " (" + backup.length + " chars)");
+      identity = backup;
+      logIdentityChange(mateDir, "restore_from_backup", identity, "");
+      identityMissing = false;
+    }
+  }
+
+  // 3. Backup identity if it's substantive
+  backupIdentity(mateDir, identity);
+
+  // 4. Rebuild the full file: identity + all system sections in order
+  //    Use dynamic team section when ctx is available, static fallback otherwise
+  var teamSection = (opts.ctx && opts.mateId) ? buildTeamSection(opts.ctx, opts.mateId) : TEAM_SECTION;
+
+  // Primary mate capabilities (dynamically injected from code)
+  var capSection = "";
+  if (opts.ctx && opts.mateId) {
+    try {
+      var mate = getMate(opts.ctx, opts.mateId);
+      capSection = buildPrimaryCapabilitiesSection(mate);
+    } catch (e) {}
+  }
+
+  // Project registry (dynamically injected when project list is available)
+  var projSection = "";
+  if (opts.projects) {
+    projSection = buildProjectRegistrySection(opts.projects);
+  }
+
+  var rebuilt = (identity || "").trimEnd();
+  rebuilt += teamSection;
+  rebuilt += projSection;
+  rebuilt += capSection;
+  rebuilt += SESSION_MEMORY_SECTION;
+  rebuilt += STICKY_NOTES_SECTION;
+  rebuilt += DEBATE_AWARENESS_SECTION;
+  rebuilt += crisisSafety.getSection();
+
+  // 5. Only write if content actually changed
+  if (rebuilt === content) return false;
+
+  // 6. Warn about missing identity only once per path, and only when actually writing
+  if (identityMissing && !_warnedPaths[filePath]) {
+    _warnedPaths[filePath] = true;
+    console.log("[mates] WARNING: Identity missing in " + filePath + " and no backup available");
+  }
+
+  // 7. Track identity changes (compare stripped versions)
+  var prevIdentity = stripAllSystemSections(content);
+  if (identity !== prevIdentity) {
+    logIdentityChange(mateDir, "enforce", identity, prevIdentity);
+  }
+
+  fs.writeFileSync(filePath, rebuilt, "utf8");
+  return true;
+}
+
 // --- Common knowledge registry ---
 
 function commonKnowledgePath(ctx) {
@@ -784,6 +1054,9 @@ function createBuiltinMate(ctx, builtinKey) {
     },
     bio: def.bio,
     status: "ready",
+    primary: !!def.primary,
+    globalSearch: !!def.globalSearch,
+    templateVersion: def.templateVersion || 0,
     interviewProjectPath: null,
   };
 
@@ -813,12 +1086,25 @@ function createBuiltinMate(ctx, builtinKey) {
 
   // Write CLAUDE.md with full template + system sections
   var claudeMd = def.getClaudeMd();
+  var builtinIdentity = claudeMd.trimEnd();
   claudeMd += TEAM_SECTION;
   claudeMd += SESSION_MEMORY_SECTION;
   claudeMd += STICKY_NOTES_SECTION;
+  claudeMd += DEBATE_AWARENESS_SECTION;
   claudeMd += crisisSafety.getSection();
   fs.writeFileSync(path.join(mateDir, "CLAUDE.md"), claudeMd);
 
+  // Backup identity and log creation
+  backupIdentity(mateDir, builtinIdentity);
+  logIdentityChange(mateDir, "create_builtin", builtinIdentity, "");
+
+  // Save base template for primary mates (used for 3-way sync comparison)
+  if (def.primary) {
+    try {
+      fs.writeFileSync(path.join(mateDir, "knowledge", "base-template.md"), builtinIdentity, "utf8");
+    } catch (e) {}
+  }
+
   return mate;
 }
 
@@ -858,6 +1144,128 @@ function ensureBuiltinMates(ctx, deletedKeys) {
   return created;
 }
 
+/**
+ * Sync primary mates with their latest code definition.
+ *
+ * Primary mates (def.primary === true) are system infrastructure, not just
+ * pre-made mates. They are the only mates whose identity, metadata, and
+ * capabilities are managed by code rather than by the user.
+ *
+ * What gets synced:
+ * - Metadata: bio, name, profile, globalSearch, primary flag
+ * - CLAUDE.md identity: re-applied when templateVersion changes
+ * - templateVersion is stored on the mate object to track updates
+ *
+ * What is NOT synced (regular builtin mates):
+ * - Arch, Rush, Ward, Pixel, Buzz are left as-is after creation
+ *
+ * Returns array of synced mate IDs.
+ */
+function syncPrimaryMates(ctx) {
+  var builtinMates = require("./builtin-mates");
+  var primaryDefs = builtinMates.getPrimaryMates();
+  if (primaryDefs.length === 0) return [];
+
+  var data = loadMates(ctx);
+  var synced = [];
+
+  for (var pi = 0; pi < primaryDefs.length; pi++) {
+    var def = primaryDefs[pi];
+
+    // Find the installed mate matching this primary definition
+    var mate = null;
+    for (var mi = 0; mi < data.mates.length; mi++) {
+      if (data.mates[mi].builtinKey === def.key) { mate = data.mates[mi]; break; }
+    }
+    if (!mate) continue; // not installed yet (ensureBuiltinMates handles creation)
+
+    var changed = false;
+
+    // --- Sync metadata (always, every startup) ---
+    if (mate.bio !== def.bio) { mate.bio = def.bio; changed = true; }
+    if (mate.name !== def.displayName) { mate.name = def.displayName; changed = true; }
+    if (!mate.primary) { mate.primary = true; changed = true; }
+    if (!mate.globalSearch && def.globalSearch) { mate.globalSearch = true; changed = true; }
+    if (mate.profile) {
+      if (mate.profile.displayName !== def.displayName) {
+        mate.profile.displayName = def.displayName; changed = true;
+      }
+    }
+
+    // --- Sync CLAUDE.md identity (only when templateVersion changes) ---
+    // Uses 3-way comparison to preserve user/Ally modifications:
+    // - base-template.md = the template that was last synced (what code wrote)
+    // - current identity = what's in CLAUDE.md now (may have been modified)
+    // - new template = latest code definition
+    //
+    // If current identity === old base → user didn't touch it → safe to replace
+    // If current identity !== old base → user/Ally modified it → preserve, skip identity sync
+    var currentVersion = mate.templateVersion || 0;
+    var latestVersion = def.templateVersion || 0;
+
+    if (latestVersion > currentVersion) {
+      var mateDir = getMateDir(ctx, mate.id);
+      var claudePath = path.join(mateDir, "CLAUDE.md");
+      var basePath = path.join(mateDir, "knowledge", "base-template.md");
+      var latestIdentity = def.getClaudeMd().trimEnd();
+
+      try {
+        var currentIdentity = "";
+        if (fs.existsSync(claudePath)) {
+          currentIdentity = extractIdentity(fs.readFileSync(claudePath, "utf8"));
+        }
+
+        // Load the base template from last sync
+        var oldBase = "";
+        try { oldBase = fs.readFileSync(basePath, "utf8").trimEnd(); } catch (e) {}
+
+        var shouldUpdateIdentity = false;
+        if (!currentIdentity || currentIdentity.length < IDENTITY_MIN_LENGTH) {
+          // No identity at all, always apply
+          shouldUpdateIdentity = true;
+        } else if (!oldBase || currentIdentity === oldBase) {
+          // Identity unchanged from last sync (user didn't modify) → safe to update
+          shouldUpdateIdentity = true;
+        } else {
+          // User/Ally modified the identity since last sync → preserve their changes
+          console.log("[mates] Primary mate " + mate.name + ": identity modified by user/Ally, preserving (v" + currentVersion + " -> v" + latestVersion + " metadata only)");
+        }
+
+        if (shouldUpdateIdentity) {
+          // Write just the identity, then let enforceAllSections rebuild system sections
+          // (including dynamic capabilities section)
+          fs.writeFileSync(claudePath, latestIdentity, "utf8");
+          backupIdentity(mateDir, latestIdentity);
+          logIdentityChange(mateDir, "sync_primary_v" + latestVersion, latestIdentity, currentIdentity);
+          console.log("[mates] Primary mate identity updated: " + mate.name + " (v" + currentVersion + " -> v" + latestVersion + ")");
+        } else {
+          console.log("[mates] Primary mate metadata updated: " + mate.name + " (v" + currentVersion + " -> v" + latestVersion + ", identity preserved)");
+        }
+
+        // Re-run enforceAllSections to inject latest dynamic sections (capabilities, team, etc.)
+        enforceAllSections(claudePath, { ctx: ctx, mateId: mate.id });
+
+        // Save the latest template as base for future 3-way comparison
+        try {
+          fs.mkdirSync(path.join(mateDir, "knowledge"), { recursive: true });
+          fs.writeFileSync(basePath, latestIdentity, "utf8");
+        } catch (e) {}
+
+      } catch (e) {
+        console.error("[mates] Failed to sync primary mate " + mate.id + ":", e.message);
+      }
+
+      mate.templateVersion = latestVersion;
+      changed = true;
+    }
+
+    if (changed) synced.push(mate.id);
+  }
+
+  if (synced.length > 0) saveMates(ctx, data);
+  return synced;
+}
+
 module.exports = {
   resolveMatesRoot: resolveMatesRoot,
   buildMateCtx: buildMateCtx,
@@ -894,8 +1302,17 @@ module.exports = {
   enforceDebateAwareness: enforceDebateAwareness,
   DEBATE_AWARENESS_MARKER: DEBATE_AWARENESS_MARKER,
   DEBATE_AWARENESS_SECTION: DEBATE_AWARENESS_SECTION,
+  enforceAllSections: enforceAllSections,
+  buildTeamSection: buildTeamSection,
+  buildPrimaryCapabilitiesSection: buildPrimaryCapabilitiesSection,
+  PRIMARY_CAPABILITIES_MARKER: PRIMARY_CAPABILITIES_MARKER,
+  extractIdentity: extractIdentity,
+  backupIdentity: backupIdentity,
+  loadIdentityBackup: loadIdentityBackup,
+  logIdentityChange: logIdentityChange,
   createBuiltinMate: createBuiltinMate,
   getInstalledBuiltinKeys: getInstalledBuiltinKeys,
   getMissingBuiltinKeys: getMissingBuiltinKeys,
   ensureBuiltinMates: ensureBuiltinMates,
+  syncPrimaryMates: syncPrimaryMates,
 };