clay-server 4.0.0-beta.15 → 4.0.0-beta.17

package/lib/capsule-frame-server.js

@@ -132,8 +132,34 @@ function createCapsuleFrameServer(opts) {
       "    if (data.type === \"state\" && typeof api.onState === \"function\") api.onState(data.state || {});",
       "    else if (data.type === \"event\" && typeof api.onEvent === \"function\") api.onEvent(data.event || null);",
       "  });",
+      "  // The host owns the iframe box, so the frame reports its natural",
+      "  // content height and the host resizes the box to fit. Without this",
+      "  // the box stays fixed and a widening layout clips the element.",
+      "  var reportedHeight = 0;",
+      "  var reportQueued = false;",
+      "  function reportSize() {",
+      "    reportQueued = false;",
+      "    var root = document.documentElement;",
+      "    var body = document.body;",
+      "    var height = Math.ceil(Math.max(root ? root.scrollHeight : 0, body ? body.scrollHeight : 0));",
+      "    if (!height || height === reportedHeight) return;",
+      "    reportedHeight = height;",
+      "    window.parent.postMessage({ clayCapsuleFrame: 1, type: \"size\", height: height }, \"*\");",
+      "  }",
+      "  function queueReport() {",
+      "    if (reportQueued) return;",
+      "    reportQueued = true;",
+      "    if (typeof requestAnimationFrame === \"function\") requestAnimationFrame(reportSize);",
+      "    else setTimeout(reportSize, 50);",
+      "  }",
+      "  if (typeof ResizeObserver === \"function\") {",
+      "    new ResizeObserver(queueReport).observe(document.documentElement);",
+      "    if (document.body) new ResizeObserver(queueReport).observe(document.body);",
+      "  }",
+      "  window.addEventListener(\"resize\", queueReport);",
       "  window.addEventListener(\"load\", function () {",
       "    window.parent.postMessage({ clayCapsuleFrame: 1, type: \"ready\" }, \"*\");",
+      "    queueReport();",
       "  });",
       "})();",
     ].join("\n");

package/lib/capsule-mate-turn.js

@@ -0,0 +1,105 @@
+// Bridges Capsule engagement events to the opponent Mate's session.
+//
+// This module knows no game. A Capsule's Logic declares on its causal event
+// when the Mate should be engaged (`event.engage = {kind}`): "turn" asks the
+// Mate to read the state and act, "start" asks it to acknowledge a fresh
+// game without acting. The bridge only carries that declaration: it finds the
+// opponent Mate's project and delivers a prompt through it, so the Capsule
+// round-trips for every game alike: the human plays on the Display, the Mate
+// wakes up, reads the state over clay_tool_snapshot, and acts through the
+// same clay_tool_act pipeline. The prompt carries words only; it grants no
+// authority the Mate does not already have, and a lost prompt costs a
+// reminder, never the game. Only human-caused events engage, whatever Logic
+// declares, so a Mate can never wake itself.
+//
+// The opponent is the Mate that last acted on this Capsule for this user.
+// Before any Mate has acted, the built-in host Mate (Clay) takes the seat, so
+// a fresh game is playable with zero setup.
+
+function attachCapsuleMateTurn(deps) {
+  var users = deps.users;
+  var findMateProject = deps.findMateProject || null;
+  var broadcastToUser = deps.broadcastToUser || null;
+  var opponents = Object.create(null);
+  var nudgedSeqs = Object.create(null);
+
+  function keyFor(userId, toolId) {
+    return String(userId) + "\u0000" + String(toolId);
+  }
+
+  // Called when a Mate acts on a Capsule: that Mate holds the opponent seat
+  // for this user's game from then on.
+  function rememberOpponent(userId, toolId, mateId) {
+    if (typeof mateId === "string" && mateId) opponents[keyFor(userId, toolId)] = mateId;
+  }
+
+  function turnPrompt(manifest) {
+    return "Capsule turn: it is your seat's turn in the \"" + manifest.name + "\" Capsule (toolId \"" + manifest.id + "\"). "
+      + "Read the game with clay_tool_snapshot, decide your move, and take your turn with clay_tool_act. "
+      + "Keep playing until the turn passes away from your seat, and say your reasoning in one or two short sentences as you play. "
+      + "If an act is refused, read the snapshot again instead of retrying blindly.";
+  }
+
+  function startPrompt(manifest) {
+    return "Capsule game: the user just started a new game of \"" + manifest.name + "\" (toolId \"" + manifest.id + "\") against you. "
+      + "The user moves first. Reply with one short line of table talk, and do not call clay_tool_act now: "
+      + "you will be woken in this session whenever it is your turn.";
+  }
+
+  // Fire-and-forget from the act pipeline: delivers a Logic-declared
+  // engagement exactly once per event, and only for human-caused events.
+  function maybeNudge(userId, manifest, actor, event) {
+    if (!findMateProject || !manifest || !event) return Promise.resolve(null);
+    if (actor !== "human") return Promise.resolve(null);
+    var kind = event.engage && (event.engage.kind === "turn" || event.engage.kind === "start") ? event.engage.kind : null;
+    if (!kind) return Promise.resolve(null);
+    var key = keyFor(userId, manifest.id);
+    if (nudgedSeqs[key] !== undefined && event.seq <= nudgedSeqs[key]) return Promise.resolve(null);
+    nudgedSeqs[key] = event.seq;
+    return Promise.resolve().then(function () {
+      var mateId = opponents[key] || null;
+      // The mates registry keys single-user data off a null userId, exactly
+      // like the home chat surface does.
+      var mateUserId = users.isMultiUser() ? userId : null;
+      var found = findMateProject(mateUserId, mateId, true);
+      if (!found && mateId) found = findMateProject(mateUserId, null, true);
+      if (!found || !found.ctx || typeof found.ctx.deliverCapsuleTurn !== "function") {
+        console.error("[capsules] No Mate project could take the '" + manifest.id + "' turn; is a Mate installed?");
+        return null;
+      }
+      var principal = { userId: users.isMultiUser() ? userId : null };
+      var mateId = found.mate && found.mate.id ? found.mate.id : null;
+      return found.ctx.deliverCapsuleTurn(principal, {
+        toolId: manifest.id,
+        toolName: manifest.name,
+        kind: kind,
+        text: kind === "turn" ? turnPrompt(manifest) : startPrompt(manifest),
+      }).then(function (delivered) {
+        // An explicit game start navigates the user's home board into the
+        // Mate's game session, so starting a game visibly opens the table.
+        if (broadcastToUser && delivered && delivered.reference && mateId) {
+          broadcastToUser(userId, {
+            type: "capsule_game_session",
+            toolId: manifest.id,
+            toolName: manifest.name,
+            mateId: mateId,
+            sessionId: delivered.reference,
+            kind: kind,
+            created: !!delivered.created,
+          });
+        }
+        return delivered;
+      });
+    }).catch(function (error) {
+      console.error("[capsules] Could not deliver the Mate's turn:", error && error.message ? error.message : error);
+      return null;
+    });
+  }
+
+  return {
+    rememberOpponent: rememberOpponent,
+    maybeNudge: maybeNudge,
+  };
+}
+
+module.exports = { attachCapsuleMateTurn: attachCapsuleMateTurn };

package/lib/capsule-pig-logic.js

@@ -159,6 +159,18 @@ function reset(state, seat) {
   return newGame();
 }
 
+function statusTextFor(state, complete, userTurn) {
+  if (complete) {
+    return state.winner === USER ? "You win this game!" : "Your Mate wins this game.";
+  }
+  if (userTurn) {
+    return state.turnTotal > 0
+      ? "Your turn: roll again or hold to bank " + state.turnTotal + " point(s)."
+      : "Your turn: roll the die.";
+  }
+  return "Your Mate's turn. Moves appear here as they happen.";
+}
+
 // The projection a Display renders and a Mate reads. It adds no meaning that is
 // absent from state: every derived field is a restatement of the fields above.
 // The score series exist because a progress chart binds to a collection.
@@ -172,7 +184,12 @@ function project(state) {
     userScoreSeries: [{ seat: SEAT_LABELS.user, value: state.scores.user }],
     mateScoreSeries: [{ seat: SEAT_LABELS.mate, value: state.scores.mate }],
     turnTotal: state.turnTotal,
+    turnTotalSeries: [{ label: "Turn total", value: state.turnTotal }],
     turnTotalText: "Turn total " + state.turnTotal + " of " + state.target + ", " + SEAT_LABELS[state.turn] + " to play.",
+    statusText: statusTextFor(state, complete, userTurn),
+    lastRollText: state.lastRoll === null
+      ? "No rolls yet."
+      : "Last roll: " + state.lastRoll + " by " + SEAT_LABELS[state.lastActor || state.turn] + ".",
     lastRoll: state.lastRoll,
     lastActor: state.lastActor,
     winner: state.winner,
@@ -184,17 +201,32 @@ function project(state) {
   };
 }
 
+// When the Mate should be engaged is a game rule, so Logic declares it on the
+// event rather than the host inferring it from Pig's fields. The host bridge
+// delivers any declared engagement generically for every Capsule: "turn"
+// means play your seat now, "start" means the human opened a fresh game and
+// you should acknowledge it without acting.
+function engagementFor(seat, actionId, next) {
+  if (seat !== USER) return null;
+  if (next.status === "playing" && next.turn === MATE) return { kind: "turn" };
+  if (actionId === "reset" && next.status === "playing") return { kind: "start" };
+  return null;
+}
+
 // Causality for the live Display: {actor, action, previous, next} plus a
 // monotonic seq. Sending only the new state would make a Mate's move teleport
 // onto the human's screen; the event lets the Display replay and attribute it.
 function buildEvent(seat, actionId, previous, next) {
-  return {
+  var event = {
     seq: next.eventSeq,
     actor: seat,
     action: actionId,
     previous: previous,
     next: next,
   };
+  var engage = engagementFor(seat, actionId, next);
+  if (engage) event.engage = engage;
+  return event;
 }
 
 function seatFor(context) {

package/lib/capsule-server-runtimes.js

@@ -13,11 +13,9 @@ var path = require("path");
 var toolStorage = require("./tool-storage");
 var toolsRegistry = require("./tools-registry");
 var pigLogic = require("./capsule-pig-logic");
-var tictactoeLogic = require("./capsule-tictactoe-logic");
 
 var RUNTIME_FACTORIES = {
   pig: pigLogic.createRuntime,
-  tictactoe: tictactoeLogic.createRuntime,
 };
 
 function hasRuntime(toolId) {

package/lib/capsules/pig/display.js

@@ -42,6 +42,14 @@
   controls.style.marginTop = "10px";
   root.appendChild(controls);
 
+  var rulesEl = document.createElement("p");
+  rulesEl.textContent = "Pig is a push-your-luck dice game: roll to build this turn's total, but a 1 loses it. Hold to bank your points; the first player to 100 wins.";
+  rulesEl.style.margin = "12px 0 0";
+  rulesEl.style.color = "#b8b8b8";
+  rulesEl.style.fontSize = "12px";
+  rulesEl.style.lineHeight = "1.45";
+  root.appendChild(rulesEl);
+
   function makeButton(label, action, accent) {
     var button = document.createElement("button");
     button.type = "button";

package/lib/capsules/pig/manifest.json

@@ -5,5 +5,5 @@
   "lucideIcon": "sparkles",
   "description": "Two-player push-your-luck dice game shared by the user and one Mate.",
   "useWhen": "Use when the user wants to play Pig, take a turn, or hear how the current game stands.",
-  "skills": "# Pig\n\nA two-seat push-your-luck dice game. The seats are `user` and `mate`; the person holds the user seat and you hold the mate seat. All randomness, turn order, and scoring are enforced server-side by the Capsule's Logic; you cannot roll a die yourself, and neither can the user.\n\n## Rules\n\n- Seats alternate turns. On your turn you may roll as often as you like.\n- Each roll adds its face value to the turn total. Rolling a 1 loses the entire turn total and passes play to the other seat.\n- Holding banks the turn total into your score and passes play.\n- The first seat to bank at least 100 points wins. A finished game is frozen until it is reset.\n- Only the user may reset a game that is still in progress. You may reset once the game is complete.\n\n## How to play\n\n1. `clay_tool_snapshot` with toolId `pig` to read the current state: `turn`, `scores.user`, `scores.mate`, `turnTotal`, `status`, `winner`, and `recentRolls`, which lists recent rolls only and never holds or wins.\n2. Act only when `turn` is `mate`. `clay_tool_act` with actionId `roll`, `hold`, or `reset`. Arguments are not used.\n3. An out-of-turn or post-game call is refused by Logic with an explanatory error. Read the snapshot again rather than retrying blindly.\n4. Every act returns the complete new state, so a snapshot immediately after an act is redundant.\n\n## Playing well\n\nThe interesting part of this Capsule is the judgement call, not the mechanics: decide whether to roll again or hold, and say why in your own words before you act. Typical play holds at a turn total near 20, but the score gap matters more than the rule of thumb, so explain the trade-off you are taking. Never claim a roll result before the act returns it."
+  "skills": "# Pig\n\nA two-seat push-your-luck dice game. The seats are `user` and `mate`; the person holds the user seat and you hold the mate seat. All randomness, turn order, and scoring are enforced server-side by the Capsule's Logic; you cannot roll a die yourself, and neither can the user.\n\n## Rules\n\n- Seats alternate turns. On your turn you may roll as often as you like.\n- Each roll adds its face value to the turn total. Rolling a 1 loses the entire turn total and passes play to the other seat.\n- Holding banks the turn total into your score and passes play.\n- The first seat to bank at least 100 points wins. A finished game is frozen until it is reset.\n- Only the user may reset a game that is still in progress. You may reset once the game is complete.\n\n## How to play\n\n1. `clay_tool_snapshot` with toolId `pig` to read the current state: `turn`, `scores.user`, `scores.mate`, `turnTotal`, `status`, `winner`, and `recentRolls`, which lists recent rolls only and never holds or wins.\n2. Act only when `turn` is `mate`. `clay_tool_act` with actionId `roll`, `hold`, or `reset`. Arguments are not used.\n3. An out-of-turn or post-game call is refused by Logic with an explanatory error. Read the snapshot again rather than retrying blindly.\n4. Every act returns the complete new state, so a snapshot immediately after an act is redundant.\n\n## Playing well\n\nThe interesting part of this Capsule is the judgement call, not the mechanics: decide whether to roll again or hold, and say why in your own words before you act. Typical play holds at a turn total near 20, but the score gap matters more than the rule of thumb, so explain the trade-off you are taking. Never claim a roll result before the act returns it.\n\n## Turn flow\n\nWhen the user's move hands the turn to your seat, Clay wakes you in a dedicated game session with a \"Capsule turn\" message. Take your whole turn there: roll as often as you judge right, then hold (or bust), and stop once the turn passes away from your seat. The user's Display updates live as you act, so never narrate moves you have not made. If nothing wakes you, you are not on turn."
 }

package/lib/capsules/pig/ui.json

@@ -3,16 +3,42 @@
   "props": { "gap": "md" },
   "children": [
     {
-      "type": "chart",
-      "bind": "userScoreSeries",
-      "props": { "label": "Your score", "kind": "progress", "categoryKey": "seat", "valueKey": "value", "max": 100 }
+      "type": "callout",
+      "when": { "equals": { "path": "$state.complete", "value": true } },
+      "props": { "title": "Game over", "text": { "$bind": "$state.statusText", "fallback": "Game over." }, "icon": "circle-check", "variant": "soft" },
+      "else": {
+        "type": "callout",
+        "props": { "title": "Pig", "text": { "$bind": "$state.statusText", "fallback": "Your turn: roll the die." }, "icon": "sparkles", "variant": "soft" }
+      }
     },
     {
-      "type": "chart",
-      "bind": "mateScoreSeries",
-      "props": { "label": "Your Mate's score", "kind": "progress", "categoryKey": "seat", "valueKey": "value", "max": 100 }
+      "type": "row",
+      "props": { "gap": "md", "wrap": true },
+      "children": [
+        {
+          "type": "chart",
+          "bind": "userScoreSeries",
+          "props": { "label": "Your score", "kind": "progress", "categoryKey": "seat", "valueKey": "value", "max": 100 }
+        },
+        {
+          "type": "chart",
+          "bind": "mateScoreSeries",
+          "props": { "label": "Your Mate's score", "kind": "progress", "categoryKey": "seat", "valueKey": "value", "max": 100 }
+        }
+      ]
+    },
+    {
+      "type": "row",
+      "props": { "gap": "md", "align": "center", "wrap": true },
+      "children": [
+        {
+          "type": "chart",
+          "bind": "turnTotalSeries",
+          "props": { "label": "Turn total", "kind": "metric", "valueKey": "value" }
+        },
+        { "type": "text", "props": { "text": { "$bind": "$state.lastRollText", "fallback": "No rolls yet." }, "role": "muted" } }
+      ]
     },
-    { "type": "text", "props": { "text": { "$bind": "$state.turnTotalText", "fallback": "Turn total 0 of 100." }, "role": "output" } },
     {
       "type": "row",
       "props": { "gap": "sm", "wrap": true },
@@ -20,26 +46,38 @@
         {
           "type": "button",
           "action": "roll",
-          "when": { "all": [{ "equals": { "path": "$state.status", "value": "playing" } }, { "equals": { "path": "$state.turn", "value": "user" } }] },
+          "when": { "equals": { "path": "$state.userTurn", "value": true } },
           "props": { "label": "Roll", "variant": "primary" },
           "else": { "type": "button", "action": "roll", "props": { "label": "Roll", "variant": "primary", "disabled": true } }
         },
         {
           "type": "button",
           "action": "hold",
-          "when": { "all": [{ "equals": { "path": "$state.status", "value": "playing" } }, { "equals": { "path": "$state.turn", "value": "user" } }] },
+          "when": { "equals": { "path": "$state.userTurn", "value": true } },
           "props": { "label": "Hold", "variant": "secondary" },
           "else": { "type": "button", "action": "hold", "props": { "label": "Hold", "variant": "secondary", "disabled": true } }
         },
-        { "type": "button", "action": "reset", "props": { "label": "Reset", "variant": "ghost" } }
+        {
+          "type": "button",
+          "action": "reset",
+          "when": { "equals": { "path": "$state.complete", "value": true } },
+          "props": { "label": "New game", "variant": "primary" },
+          "else": { "type": "button", "action": "reset", "props": { "label": "Start over", "variant": "ghost" } }
+        }
       ]
     },
     {
-      "type": "list",
-      "bind": "recentRolls",
-      "props": { "variant": "divided", "gap": "xs" },
+      "type": "section",
+      "props": { "label": "Recent rolls", "variant": "inset", "gap": "xs" },
       "children": [
-        { "type": "text", "props": { "text": "$item.text", "role": "body" } }
+        {
+          "type": "list",
+          "bind": "recentRolls",
+          "props": { "variant": "divided", "gap": "xs" },
+          "children": [
+            { "type": "text", "props": { "text": "$item.text", "role": "body" } }
+          ]
+        }
       ]
     }
   ]

package/lib/daemon-projects.js

@@ -7,6 +7,7 @@
 var fs = require("fs");
 var { scanWorktrees, isWorktree } = require("./worktree");
 var { daemonSync } = require("./daemon-sync");
+var logContext = require("./project-log-context");
 
 // --- Worktree tracking state ---
 var worktreeRegistry = {}; // parentSlug -> [wtSlug, ...]
@@ -28,7 +29,7 @@ function isWorktreeSlug(slug) {
  * @param {string} parentIcon - icon of parent project
  * @param {string} parentOwnerId - owner user ID
  */
-function scanAndRegisterWorktrees(relay, parentPath, parentSlug, parentIcon, parentOwnerId) {
+function scanAndRegisterWorktrees(relay, parentPath, parentSlug, parentIcon, parentOwnerId, projectKnowledgeId) {
   if (isWorktree(parentPath)) return;
   var worktrees = scanWorktrees(parentPath);
   if (worktrees.length === 0) return;
@@ -41,13 +42,14 @@ function scanAndRegisterWorktrees(relay, parentPath, parentSlug, parentIcon, par
       if (worktreeRegistry[parentSlug][j] === wtSlug) { alreadyRegistered = true; break; }
     }
     if (alreadyRegistered) continue;
-    var wtMeta = { parentSlug: parentSlug, branch: wt.branch || wt.dirName, external: wt.external };
+    var context = logContext.resolveWorktreeContext(wt.path, projectKnowledgeId, { branch: wt.branch || wt.dirName });
+    var wtMeta = Object.assign({ parentSlug: parentSlug, external: wt.external, projectKnowledgeId: projectKnowledgeId }, context);
     relay.addProject(wt.path, wtSlug, wt.branch || wt.dirName, parentIcon, parentOwnerId, wtMeta);
     worktreeRegistry[parentSlug].push(wtSlug);
     console.log("[daemon] Registered worktree:", wtSlug, "->", wt.path, wt.external ? "(external)" : "(inside project folder)");
   }
   daemonSync.register(getWorktreeSyncKey(parentSlug), function () {
-    rescanWorktrees(relay, parentPath, parentSlug, parentIcon, parentOwnerId);
+    rescanWorktrees(relay, parentPath, parentSlug, parentIcon, parentOwnerId, null, projectKnowledgeId);
   });
 }
 
@@ -60,7 +62,7 @@ function scanAndRegisterWorktrees(relay, parentPath, parentSlug, parentIcon, par
  * @param {string} parentOwnerId - owner user ID
  * @param {object} [config] - daemon config (optional, for broadcasting project count)
  */
-function rescanWorktrees(relay, parentPath, parentSlug, parentIcon, parentOwnerId, config) {
+function rescanWorktrees(relay, parentPath, parentSlug, parentIcon, parentOwnerId, config, projectKnowledgeId) {
   if (worktreeScanning[parentSlug]) return;
   worktreeScanning[parentSlug] = true;
   try {
@@ -79,7 +81,8 @@ function rescanWorktrees(relay, parentPath, parentSlug, parentIcon, parentOwnerI
         if (existingSlugs[ei] === wtSlug) { found = true; break; }
       }
       if (!found) {
-        var wtMeta = { parentSlug: parentSlug, branch: wt.branch || wt.dirName, external: wt.external };
+        var context = logContext.resolveWorktreeContext(wt.path, projectKnowledgeId, { branch: wt.branch || wt.dirName });
+        var wtMeta = Object.assign({ parentSlug: parentSlug, external: wt.external, projectKnowledgeId: projectKnowledgeId }, context);
         relay.addProject(wt.path, wtSlug, wt.branch || wt.dirName, parentIcon, parentOwnerId, wtMeta);
         if (!worktreeRegistry[parentSlug]) worktreeRegistry[parentSlug] = [];
         worktreeRegistry[parentSlug].push(wtSlug);
@@ -91,6 +94,7 @@ function rescanWorktrees(relay, parentPath, parentSlug, parentIcon, parentOwnerI
       var sSlug = existingSlugs[si];
       var dirName = sSlug.split("--").slice(1).join("--");
       if (!discoveredNames[dirName]) {
+        if (relay.setProjectLogContextState) relay.setProjectLogContextState(sSlug, "archived");
         relay.removeProject(sSlug);
         existingSlugs.splice(si, 1);
         console.log("[daemon] Rescan: removed stale worktree:", sSlug);
@@ -112,6 +116,7 @@ function rescanWorktrees(relay, parentPath, parentSlug, parentIcon, parentOwnerI
 function cleanupWorktreesForParent(relay, parentSlug) {
   var wtSlugs = worktreeRegistry[parentSlug] || [];
   for (var i = 0; i < wtSlugs.length; i++) {
+    if (relay.setProjectLogContextState) relay.setProjectLogContextState(wtSlugs[i], "archived");
     relay.removeProject(wtSlugs[i]);
     console.log("[daemon] Cascade removed worktree:", wtSlugs[i]);
   }

package/lib/daemon.js

@@ -36,6 +36,7 @@ var { createWorktree, removeWorktree, isWorktree } = require("./worktree");
 var mates = require("./mates");
 var mateKnowledgeMigration = require("./mate-knowledge-migration");
 var { isWorktreeSlug, scanAndRegisterWorktrees, rescanWorktrees, cleanupWorktreesForParent, getFilteredRemovedProjects, registerWorktreeSlug, unregisterWorktreeSlug } = require("./daemon-projects");
+var projectLogContext = require("./project-log-context");
 
 var daemonVersion = require("../package.json").version;
 var configFile = process.env.CLAY_CONFIG || process.env.CLAUDE_RELAY_CONFIG || require("./config").configPath();
@@ -65,6 +66,11 @@ try {
   console.error("[daemon] ensureMultiUser threw (continuing):", e && e.message);
 }
 
+if (projectLogContext.initializeProjectKnowledge(config)) {
+  saveConfig(config);
+  console.log("[daemon] Assigned stable knowledge identities to existing projects");
+}
+
 // --- OS users mode: check required system dependencies ---
 // Supplementary-group inheritance (issue #367): default on so sessions behave
 // like a normal login; operators can disable via config / the settings toggle.
@@ -153,6 +159,20 @@ var lanIp = (function () {
 // --- Create multi-project server ---
 var listenHost = config.host || "0.0.0.0";
 
+function rememberedProjectKnowledgeId(projectPath) {
+  var removed = config.removedProjects || [];
+  for (var i = removed.length - 1; i >= 0; i--) {
+    if (removed[i].path === projectPath && projectLogContext.validId(removed[i].projectKnowledgeId)) {
+      return removed[i].projectKnowledgeId;
+    }
+  }
+  return projectLogContext.createProjectKnowledgeId();
+}
+
+function projectRuntimeOptions(project) {
+  return { projectKnowledgeId: project.projectKnowledgeId };
+}
+
 var relay = createServer({
   tlsOptions: tlsOptions,
   caPath: caRoot,
@@ -173,13 +193,14 @@ var relay = createServer({
     }
     var slugs = config.projects.map(function (p) { return p.slug; });
     var slug = generateSlug(absPath, slugs);
-    relay.addProject(absPath, slug, null, null, wsUser ? wsUser.id : null);
     var projectEntry = { path: absPath, slug: slug, addedAt: Date.now(), visibility: "private" };
+    projectEntry.projectKnowledgeId = rememberedProjectKnowledgeId(absPath);
     // The user who adds a project always becomes the owner
     if (wsUser && wsUser.id) {
       projectEntry.ownerId = wsUser.id;
     }
     config.projects.push(projectEntry);
+    relay.addProject(absPath, slug, null, null, wsUser ? wsUser.id : null, null, projectRuntimeOptions(projectEntry));
     // Remove from removedProjects if present
     if (config.removedProjects) {
       config.removedProjects = config.removedProjects.filter(function (rp) { return rp.path !== absPath; });
@@ -198,7 +219,7 @@ var relay = createServer({
       }
     }
     // Discover and register worktrees for the new project
-    scanAndRegisterWorktrees(relay, absPath, slug, null, wsUser && wsUser.id && wsUser.role !== "admin" ? wsUser.id : null);
+    scanAndRegisterWorktrees(relay, absPath, slug, null, wsUser && wsUser.id && wsUser.role !== "admin" ? wsUser.id : null, projectEntry.projectKnowledgeId);
     // Broadcast updated project list to all clients
     relay.broadcastAll({
       type: "projects_updated",
@@ -255,10 +276,11 @@ var relay = createServer({
     }
     // Register project - creator always becomes owner, default private
     var projectEntry = { path: targetDir, slug: slug, addedAt: Date.now(), visibility: "private" };
+    projectEntry.projectKnowledgeId = projectLogContext.createProjectKnowledgeId();
     if (wsUser && wsUser.id) {
       projectEntry.ownerId = wsUser.id;
     }
-    relay.addProject(targetDir, slug, null, null, wsUser ? wsUser.id : null);
+    relay.addProject(targetDir, slug, null, null, wsUser ? wsUser.id : null, null, projectRuntimeOptions(projectEntry));
     config.projects.push(projectEntry);
     saveConfig(config);
     try { syncClayrc(config.projects); } catch (e) {}
@@ -345,10 +367,11 @@ var relay = createServer({
       // Register project - creator always becomes owner
       // Creator always becomes owner, default private
       var projectEntry = { path: targetDir, slug: slug, addedAt: Date.now(), visibility: "private" };
+      projectEntry.projectKnowledgeId = projectLogContext.createProjectKnowledgeId();
       if (wsUser && wsUser.id) {
         projectEntry.ownerId = wsUser.id;
       }
-      relay.addProject(targetDir, slug);
+      relay.addProject(targetDir, slug, null, null, wsUser ? wsUser.id : null, null, projectRuntimeOptions(projectEntry));
       config.projects.push(projectEntry);
       saveConfig(config);
       try { syncClayrc(config.projects); } catch (e) {}
@@ -380,11 +403,14 @@ var relay = createServer({
         if (config.projects[pi].slug === wtParent) { parentProject = config.projects[pi]; break; }
       }
       if (parentProject) {
+        var wtPath = path.join(parentProject.path, wtDirName);
+        var contextStatus = projectLogContext.isMerged(parentProject.path, wtPath) ? "merged" : "archived";
         var rmResult = removeWorktree(parentProject.path, wtDirName);
         if (!rmResult.ok) {
           console.log("[daemon] Failed to remove worktree:", slug, rmResult.error);
           return { ok: false, error: rmResult.error };
         }
+        relay.setProjectLogContextState(slug, contextStatus);
       }
       relay.removeProject(slug);
       unregisterWorktreeSlug(wtParent, slug);
@@ -410,6 +436,7 @@ var relay = createServer({
       title: found.title || null,
       icon: found.icon || null,
       userId: userId || null,
+      projectKnowledgeId: found.projectKnowledgeId || null,
       removedAt: Date.now(),
     });
     // Cap at 20 entries (oldest first)
@@ -740,6 +767,7 @@ var relay = createServer({
       inheritGroups: config.inheritGroups !== false,
       chatLayout: config.chatLayout || "channel",
       matesEnabled: config.matesEnabled === true,
+      capsulesEnabled: config.capsulesEnabled === true,
       pinEnabled: !!config.pinHash,
       platform: process.platform,
       hostname: os2.hostname(),
@@ -818,6 +846,13 @@ var relay = createServer({
     console.log("[daemon] Project Mate DMs:", want ? "shown" : "hidden", "(web)");
     return { ok: true, matesEnabled: want };
   },
+  onSetCapsulesEnabled: function (value) {
+    var want = value === true;
+    config.capsulesEnabled = want;
+    saveConfig(config);
+    console.log("[daemon] Experimental Capsules:", want ? "enabled" : "disabled", "(web)");
+    return { ok: true, capsulesEnabled: want };
+  },
   onGetToolPalettes: function () {
     return config.toolPalettes || {};
   },
@@ -976,11 +1011,16 @@ var relay = createServer({
     }
     if (!parent) return { ok: false, error: "Parent project not found" };
     if (isWorktree(parent.path)) return { ok: false, error: "Cannot create worktrees from a worktree project" };
+    var baseCommit = projectLogContext.commit(parent.path, baseBranch || "HEAD");
     var result = createWorktree(parent.path, branchName, dirName, baseBranch);
     if (!result.ok) return result;
     // Register the new worktree as ephemeral project
     var wtSlug = parentSlug + "--" + dirName;
-    var wtMeta = { parentSlug: parentSlug, branch: branchName, external: false };
+    var context = projectLogContext.resolveWorktreeContext(result.path, parent.projectKnowledgeId, {
+      branch: branchName,
+      baseCommit: baseCommit,
+    });
+    var wtMeta = Object.assign({ parentSlug: parentSlug, external: false, projectKnowledgeId: parent.projectKnowledgeId }, context);
     relay.addProject(result.path, wtSlug, branchName, parent.icon, parent.ownerId, wtMeta);
     registerWorktreeSlug(parentSlug, wtSlug);
     console.log("[daemon] Created worktree:", wtSlug, "->", result.path);
@@ -1066,13 +1106,15 @@ var ipc = createIPCServer(socketPath(), function (msg) {
       }
       var slugs = config.projects.map(function (p) { return p.slug; });
       var slug = generateSlug(absPath, slugs);
-      relay.addProject(absPath, slug);
-      config.projects.push({ path: absPath, slug: slug, addedAt: Date.now(), visibility: "private" });
+      var projectEntry = { path: absPath, slug: slug, addedAt: Date.now(), visibility: "private" };
+      projectEntry.projectKnowledgeId = rememberedProjectKnowledgeId(absPath);
+      relay.addProject(absPath, slug, null, null, null, null, projectRuntimeOptions(projectEntry));
+      config.projects.push(projectEntry);
       saveConfig(config);
       try { syncClayrc(config.projects); } catch (e) {}
       console.log("[daemon] Added project:", slug, "→", absPath);
       // Discover and register worktrees for the new project
-      scanAndRegisterWorktrees(relay, absPath, slug, null, null);
+      scanAndRegisterWorktrees(relay, absPath, slug, null, null, projectEntry.projectKnowledgeId);
       relay.broadcastAll({
         type: "projects_updated",
         projects: relay.getProjects(),
@@ -1094,6 +1136,23 @@ var ipc = createIPCServer(socketPath(), function (msg) {
         }
       }
       if (!target) return { ok: false, error: "project not found" };
+      var removedProject = null;
+      for (var ri = 0; ri < config.projects.length; ri++) {
+        if (config.projects[ri].slug === target) { removedProject = config.projects[ri]; break; }
+      }
+      if (removedProject) {
+        if (!config.removedProjects) config.removedProjects = [];
+        config.removedProjects.push({
+          path: removedProject.path,
+          title: removedProject.title || null,
+          icon: removedProject.icon || null,
+          projectKnowledgeId: removedProject.projectKnowledgeId || null,
+          removedAt: Date.now(),
+        });
+        if (config.removedProjects.length > 20) {
+          config.removedProjects = config.removedProjects.slice(config.removedProjects.length - 20);
+        }
+      }
       relay.removeProject(target);
       config.projects = config.projects.filter(function (p) { return p.slug !== target; });
       saveConfig(config);
@@ -1284,9 +1343,9 @@ for (var i = 0; i < projects.length; i++) {
   var p = projects[i];
   if (fs.existsSync(p.path)) {
     console.log("[daemon] Adding project:", p.slug, "→", p.path);
-    relay.addProject(p.path, p.slug, p.title, p.icon, p.ownerId);
+    relay.addProject(p.path, p.slug, p.title, p.icon, p.ownerId, null, projectRuntimeOptions(p));
     // Discover and register worktrees for this project
-    scanAndRegisterWorktrees(relay, p.path, p.slug, p.icon, p.ownerId);
+    scanAndRegisterWorktrees(relay, p.path, p.slug, p.icon, p.ownerId, p.projectKnowledgeId);
   } else {
     console.log("[daemon] Skipping missing project:", p.path);
   }

package/lib/migrate-single-user.js

@@ -23,6 +23,7 @@ var SETTING_KEYS = [
   "chatLayout",
   "autoContinueOnRateLimit",
   "matesEnabled",
+  "capsulesEnabled",
   "terminalFont",
   "deletedBuiltinKeys",
   "mateOnboardingShown",
@@ -189,6 +190,7 @@ function migrateSingleUserToMulti() {
       if (cfg.chatLayout !== undefined && users.setChatLayout) users.setChatLayout(userId, cfg.chatLayout);
       if (cfg.autoContinueOnRateLimit !== undefined && users.setAutoContinue) users.setAutoContinue(userId, cfg.autoContinueOnRateLimit);
       if (cfg.matesEnabled !== undefined && users.setMatesEnabled) users.setMatesEnabled(userId, cfg.matesEnabled);
+      if (cfg.capsulesEnabled !== undefined && users.setCapsulesEnabled) users.setCapsulesEnabled(userId, cfg.capsulesEnabled);
       if (cfg.terminalFont && users.setTerminalFont) {
         users.setTerminalFont(userId, cfg.terminalFont.family, cfg.terminalFont.size);
       }