clay-server 3.0.0 → 3.1.0-beta.1

package/lib/notes.js

@@ -59,6 +59,12 @@ function createNotesManager(opts) {
       createdAt: now,
       updatedAt: now,
     };
+    if (data.origin && data.origin.sessionId !== undefined) {
+      note.origin = {
+        sessionId: data.origin.sessionId,
+        vendor: data.origin.vendor || "claude",
+      };
+    }
     notes.push(note);
     saveToDisk();
     return note;

package/lib/project-http.js

@@ -676,13 +676,10 @@ function attachHTTP(ctx) {
           defBr = hrRef.replace(/^origin\//, "");
         } catch (e) {}
         res.writeHead(200, { "Content-Type": "application/json" });
-        res.end(JSON.stringify({ branches: brList, defaultBranch: defBr, isGitRepo: true }));
+        res.end(JSON.stringify({ branches: brList, defaultBranch: defBr }));
       } catch (e) {
-        // git failed: not a repository (or git missing). The branch chip
-        // hides itself on isGitRepo:false; the fallback branch list keeps
-        // the worktree modal from crashing if it is somehow reached.
         res.writeHead(200, { "Content-Type": "application/json" });
-        res.end(JSON.stringify({ branches: ["main"], defaultBranch: "main", isGitRepo: false }));
+        res.end(JSON.stringify({ branches: ["main"], defaultBranch: "main" }));
       }
       return true;
     }
@@ -700,7 +697,7 @@ function attachHTTP(ctx) {
         }
         var sessionId = Number(body.sessionId);
         if (!Number.isInteger(sessionId)) sessionId = null;
-        var handler = getMcpBridgeHandler(sessionId, body.pairOnly === true);
+        var handler = getMcpBridgeHandler(sessionId, body.sessionOnly === true);
         if (!handler) {
           res.writeHead(500, { "Content-Type": "application/json" });
           res.end('{"error":"MCP bridge handler unavailable"}');

package/lib/project-session-notes.js

@@ -0,0 +1,217 @@
+var sessionNotesMcp = require("./session-notes-mcp-server");
+
+var MAX_NOTE_TEXT_CHARS = 2000;
+var MAX_ACTIVE_NOTES = 20;
+var MAX_PROMPT_CHARS = 2000;
+var MAX_NOTE_PROMPT_CHARS = 240;
+var NOTES_LABEL = "--- Project sticky notes (shared memory; manage via clay-notes tools) ---";
+var NOTES_HINT = "- More notes are available; call list_notes for the rest.";
+var PROACTIVE_POLICY = "Use the board proactively: when the user states a decision, preference, correction, or durable project fact that future sessions will need, record it with write_note WITHOUT being asked, and say so in one short clause. The bar: a person skimming the board a week from now must still find the note useful, and it must stand on its own without this conversation. Never write announcement or narration notes ('leaving a note', 'did X just now'), routine progress, transient state, or anything the repo already records. Update or remove your stale notes instead of adding near-duplicates. A task should rarely add more than one or two notes.";
+var NOTE_COLORS = ["yellow", "blue", "green", "pink", "orange", "purple"];
+
+function toolResult(value) {
+  return Promise.resolve({ content: [{ type: "text", text: JSON.stringify(value) }] });
+}
+
+function toolError(message) {
+  return Promise.resolve({
+    content: [{ type: "text", text: "Error: " + message }],
+    isError: true,
+  });
+}
+
+function activeNotes(notes) {
+  return (notes || []).filter(function (note) {
+    return note && !note.hidden;
+  });
+}
+
+function memoryNotes(notes) {
+  return activeNotes(notes).filter(function (note) {
+    return typeof note.text === "string" && note.text.trim();
+  });
+}
+
+function publicNote(note) {
+  return {
+    id: note.id,
+    text: note.text,
+    color: note.color,
+    updatedAt: note.updatedAt,
+    origin: note.origin || null,
+  };
+}
+
+function findNote(notes, id) {
+  for (var i = 0; i < notes.length; i++) {
+    if (notes[i] && notes[i].id === id) return notes[i];
+  }
+  return null;
+}
+
+function autoPlacement(notes) {
+  if (!notes || notes.length === 0) return { x: 100, y: 100 };
+  var last = notes[notes.length - 1];
+  var baseX = typeof last.x === "number" ? last.x : 100;
+  var baseY = typeof last.y === "number" ? last.y : 100;
+  var step = 1;
+  while (step <= notes.length + 1) {
+    var x = baseX + step * 30;
+    var y = baseY + step * 30;
+    var occupied = notes.some(function (note) {
+      return note && note.x === x && note.y === y;
+    });
+    if (!occupied) return { x: x, y: y };
+    step++;
+  }
+  return { x: baseX + (notes.length + 2) * 30, y: baseY + (notes.length + 2) * 30 };
+}
+
+function formatNoteLine(note) {
+  var prefix = "- " + (note.color ? "[" + note.color + "] " : "");
+  var text = note.text.trim();
+  var marker = "… (list_notes for the full note)";
+  if (prefix.length + text.length <= MAX_NOTE_PROMPT_CHARS) return prefix + text;
+  var previewLength = Math.max(0, MAX_NOTE_PROMPT_CHARS - prefix.length - marker.length);
+  return prefix + text.slice(0, previewLength).trimEnd() + marker;
+}
+
+function buildNotesPrompt(notes) {
+  var newest = memoryNotes(notes).sort(function (a, b) {
+    return (b.updatedAt || b.createdAt || 0) - (a.updatedAt || a.createdAt || 0);
+  });
+  if (newest.length === 0) return NOTES_LABEL + "\n(board is empty)\n" + PROACTIVE_POLICY;
+  var lines = newest.map(formatNoteLine);
+  var full = NOTES_LABEL + "\n" + lines.join("\n");
+  if (full.length <= MAX_PROMPT_CHARS) return full + "\n" + PROACTIVE_POLICY;
+
+  var result = NOTES_LABEL;
+  var available = MAX_PROMPT_CHARS - result.length - NOTES_HINT.length - 2;
+  for (var i = 0; i < lines.length && available > 0; i++) {
+    var prefix = "\n";
+    if (prefix.length + lines[i].length <= available) {
+      result += prefix + lines[i];
+      available -= prefix.length + lines[i].length;
+      continue;
+    }
+    var partialLength = Math.max(0, available - prefix.length - 1);
+    if (partialLength > 0) result += prefix + lines[i].slice(0, partialLength) + "…";
+    break;
+  }
+  return (result + "\n" + NOTES_HINT).slice(0, MAX_PROMPT_CHARS) + "\n" + PROACTIVE_POLICY;
+}
+
+function composeSystemPrompts(parts) {
+  return (parts || []).filter(function (part) { return typeof part === "string" && part.trim(); }).join("\n\n");
+}
+
+function attachSessionNotes(ctx) {
+  var nm = ctx.nm;
+  var send = ctx.send || function () {};
+  var broadcastWritten = ctx.broadcastWritten || function () {};
+
+  function notifyWritten(note, caller) {
+    broadcastWritten({
+      type: "note_written",
+      id: note.id,
+      byTitle: caller.title || "Agent",
+      vendor: caller.vendor || "claude",
+      preview: (note.text || "").slice(0, 60),
+    });
+  }
+
+  function listNotes(args, caller) {
+    if (!caller) return toolError("list_notes requires a session-bound tool server");
+    return toolResult(activeNotes(nm.list()).map(publicNote));
+  }
+
+  function writeNote(args, caller) {
+    if (!caller) return toolError("write_note requires a session-bound tool server");
+    var rawText = typeof args.text === "string" ? args.text : "";
+    if (rawText.length > MAX_NOTE_TEXT_CHARS) return toolError("text exceeds 2000 characters");
+    var text = rawText.trim();
+    if (!text) return toolError("text is required");
+    var notes = nm.list() || [];
+    var color = NOTE_COLORS.indexOf(args.color) !== -1 ? args.color : undefined;
+    if (args.id) {
+      var existing = findNote(notes, args.id);
+      if (!existing) return toolError("note not found: " + args.id);
+      var changes = { text: text };
+      if (color) changes.color = color;
+      var updated = nm.update(args.id, changes);
+      if (!updated) return toolError("note could not be updated: " + args.id);
+      send({ type: "note_updated", note: updated });
+      notifyWritten(updated, caller);
+      return toolResult(publicNote(updated));
+    }
+    if (activeNotes(notes).length >= MAX_ACTIVE_NOTES) {
+      return toolError("20 active notes already exist; consolidate or remove stale notes before creating another");
+    }
+    var placement = autoPlacement(notes);
+    var created = nm.create({
+      text: text,
+      color: color || "yellow",
+      x: placement.x,
+      y: placement.y,
+      origin: { sessionId: caller.localId, vendor: caller.vendor || "claude" },
+    });
+    if (!created) return toolError("note could not be created");
+    send({ type: "note_created", note: created });
+    notifyWritten(created, caller);
+    return toolResult(publicNote(created));
+  }
+
+  function removeNote(args, caller) {
+    if (!caller) return toolError("remove_note requires a session-bound tool server");
+    var note = findNote(nm.list() || [], args.id);
+    if (!note) return toolError("note not found: " + (args.id || "unknown"));
+    if (!note.origin || note.origin.sessionId !== caller.localId) {
+      return toolError("this session can only remove notes it created");
+    }
+    if (!nm.remove(note.id)) return toolError("note could not be removed: " + note.id);
+    send({ type: "note_deleted", id: note.id });
+    return toolResult({ removed: true, id: note.id });
+  }
+
+  function getToolDefs(boundSession) {
+    if (ctx.isMate) return [];
+    return sessionNotesMcp.getToolDefs({
+      list: function (args) { return listNotes(args, boundSession || null); },
+      write: function (args) { return writeNote(args, boundSession || null); },
+      remove: function (args) { return removeNote(args, boundSession || null); },
+    });
+  }
+
+  function createMcpServer(adapter, boundSession) {
+    if (ctx.isMate || !adapter || typeof adapter.createToolServer !== "function") return null;
+    return adapter.createToolServer({
+      name: "clay-notes",
+      version: "1.0.0",
+      tools: getToolDefs(boundSession || null),
+    });
+  }
+
+  function getSystemPrompt() {
+    if (ctx.isMate) return "";
+    return buildNotesPrompt(nm.list());
+  }
+
+  return {
+    createMcpServer: createMcpServer,
+    getSystemPrompt: getSystemPrompt,
+    getToolDefs: getToolDefs,
+  };
+}
+
+module.exports = {
+  MAX_NOTE_TEXT_CHARS: MAX_NOTE_TEXT_CHARS,
+  MAX_ACTIVE_NOTES: MAX_ACTIVE_NOTES,
+  MAX_NOTE_PROMPT_CHARS: MAX_NOTE_PROMPT_CHARS,
+  MAX_PROMPT_CHARS: MAX_PROMPT_CHARS,
+  NOTES_LABEL: NOTES_LABEL,
+  PROACTIVE_POLICY: PROACTIVE_POLICY,
+  attachSessionNotes: attachSessionNotes,
+  autoPlacement: autoPlacement,
+  buildNotesPrompt: buildNotesPrompt,
+  composeSystemPrompts: composeSystemPrompts,
+};

package/lib/project.js

@@ -32,6 +32,7 @@ var { createLocalMcp } = require("./mcp-local");
 var { attachEmail: attachEmailModule } = require("./project-email");
 var { attachSessionSpawn } = require("./project-session-spawn");
 var { attachSessionPair } = require("./project-session-pair");
+var { attachSessionNotes, composeSystemPrompts } = require("./project-session-notes");
 var { attachSplitGroups } = require("./session-split-groups");
 // project-notifications is attached globally in server.js, passed via opts.notificationsModule
 
@@ -492,6 +493,21 @@ function createProjectContext(opts) {
     },
   });
 
+  // Sticky-note storage is initialized before session tool wiring so every
+  // vendor receives the same handlers and prompt snapshot at query start.
+  var nm = createNotesManager({ cwd: cwd, send: send, sendTo: sendTo });
+  var _sessionNotes = attachSessionNotes({
+    nm: nm,
+    send: send,
+    isMate: isMate,
+    broadcastWritten: function (message) {
+      for (var noteWs of clients) {
+        if (noteWs.readyState !== 1 || noteWs._clayPane) continue;
+        sendTo(noteWs, message);
+      }
+    },
+  });
+
   // The SDK bridge is created after local MCP servers. Session spawning uses
   // a getter so tool handlers see the initialized bridge when they run.
   var _sessionPair = attachSessionPair({
@@ -539,6 +555,16 @@ function createProjectContext(opts) {
       }
     }
 
+    // Shared sticky-note memory (main projects only).
+    if (!isMate) {
+      try {
+        var sessionNotesMcpConfig = _sessionNotes.createMcpServer(adapter);
+        if (sessionNotesMcpConfig) servers[sessionNotesMcpConfig.name || "clay-notes"] = sessionNotesMcpConfig;
+      } catch (e) {
+        console.error("[project] Failed to create session notes MCP server:", e.message);
+      }
+    }
+
     // Debate MCP server (available to both mates and main project)
     try {
       var debateMcp = require("./debate-mcp-server");
@@ -702,15 +728,14 @@ function createProjectContext(opts) {
   //   clay-email   -> only when the user has an account or server SMTP
   //
   // forSession (optional): the session whose query these servers are mounted
-  // into. clay-sessions must know its caller (depth guard + child ownership),
-  // so it is re-instantiated bound to that session; the static instance in
-  // mcpServers only serves descriptor listing and fails closed on calls.
+  // into. clay-sessions and clay-notes must know their caller for depth and
+  // ownership rules, so they are re-instantiated bound to that session; the
+  // static instances only serve descriptor listing and fail closed on calls.
   function getLocalMcpServers(forSession) {
-    if (!mcpServers) return undefined;
     var extWs = browserState._extensionWs;
     var extConnected = !!(extWs && extWs.readyState === 1);
     var emailAvailable = !!(_email && typeof _email.hasEmailCapability === "function" && _email.hasEmailCapability());
-    var keys = Object.keys(mcpServers);
+    var keys = Object.keys(mcpServers || {});
     var filtered = {};
     var hasAny = false;
     for (var i = 0; i < keys.length; i++) {
@@ -726,6 +751,15 @@ function createProjectContext(opts) {
         }
         continue;
       }
+      if (name === "clay-notes" && forSession) {
+        try {
+          var boundNotes = _sessionNotes.createMcpServer(adapter, forSession);
+          if (boundNotes) { filtered[name] = boundNotes; hasAny = true; }
+        } catch (e) {
+          console.error("[project] Failed to bind session notes MCP server:", e.message);
+        }
+        continue;
+      }
       filtered[name] = mcpServers[name];
       hasAny = true;
     }
@@ -769,8 +803,15 @@ function createProjectContext(opts) {
       }
       return false;
     },
-    getSessionSystemPrompt: function (session) { return _sessionPair.getSystemPrompt(session); },
-    getSessionToolDefs: function (session) { return _sessionPair.getToolDefs(session); },
+    getSessionSystemPrompt: function (session) {
+      return composeSystemPrompts([
+        _sessionPair.getSystemPrompt(session),
+        _sessionNotes.getSystemPrompt(session),
+      ]);
+    },
+    getSessionToolDefs: function (session) {
+      return _sessionPair.getToolDefs(session).concat(_sessionNotes.getToolDefs(session));
+    },
   });
 
   // --- Loop engine (delegated to project-loop.js) ---
@@ -807,7 +848,6 @@ function createProjectContext(opts) {
 
   // --- Terminal manager ---
   var tm = createTerminalManager({ cwd: cwd, send: send, sendTo: sendTo });
-  var nm = createNotesManager({ cwd: cwd, send: send, sendTo: sendTo });
 
   // Check for updates in background (admin only). The result is stored in
   // latestVersion; broadcast is handled by the hourly scheduler below, so
@@ -1375,8 +1415,8 @@ function createProjectContext(opts) {
   // --- MCP bridge handler for Codex and session-bound Kiro tools ---
   // Provides list_tools and call_tool operations over HTTP for mcp-bridge-server.js.
   // The normal Codex bridge excludes local MCP servers it manages natively;
-  // Kiro's pair-only bridge exposes only the tools bound to its Clay session.
-  function getMcpBridgeHandler(sessionId, pairOnly) {
+  // Kiro's session-only bridge exposes only tools bound to its Clay session.
+  function getMcpBridgeHandler(sessionId, sessionOnly) {
     var boundSession = Number.isInteger(sessionId) ? sm.sessions.get(sessionId) : null;
     // Build set of local MCP server names to exclude (Codex handles these natively)
     var localMcpNames = {};
@@ -1393,7 +1433,19 @@ function createProjectContext(opts) {
       listTools: function () {
         var tools = [];
         var toJSONSchema;
-        try { toJSONSchema = require("zod").toJSONSchema; } catch (e) { /* fallback */ }
+        var zod;
+        try { zod = require("zod"); toJSONSchema = zod.toJSONSchema; } catch (e) { /* fallback */ }
+
+        function normalizeToolSchema(inputSchema) {
+          if (inputSchema && typeof inputSchema.type === "string") return inputSchema;
+          try {
+            if (toJSONSchema && inputSchema) {
+              var schema = inputSchema.safeParse ? inputSchema : zod.object(inputSchema);
+              return toJSONSchema(schema);
+            }
+          } catch (e) { /* fallback */ }
+          return { type: "object", properties: {} };
+        }
 
         // Helper to extract tools from an SDK MCP server object
         function extractServerTools(serverName, server) {
@@ -1401,10 +1453,7 @@ function createProjectContext(opts) {
           var toolNames = Object.keys(server.instance._registeredTools);
           for (var j = 0; j < toolNames.length; j++) {
             var toolDef = server.instance._registeredTools[toolNames[j]];
-            var inputSchema = { type: "object", properties: {} };
-            try {
-              if (toJSONSchema && toolDef.inputSchema) inputSchema = toJSONSchema(toolDef.inputSchema);
-            } catch (e) { /* fallback */ }
+            var inputSchema = normalizeToolSchema(toolDef.inputSchema);
             tools.push({
               server: serverName,
               name: toolNames[j],
@@ -1421,12 +1470,21 @@ function createProjectContext(opts) {
               server: "clay-sessions",
               name: pairTools[pti].name,
               description: pairTools[pti].description || pairTools[pti].name,
-              inputSchema: pairTools[pti].inputSchema || { type: "object", properties: {} },
+              inputSchema: normalizeToolSchema(pairTools[pti].inputSchema),
+            });
+          }
+          var noteTools = _sessionNotes.getToolDefs(boundSession);
+          for (var nti = 0; nti < noteTools.length; nti++) {
+            tools.push({
+              server: "clay-notes",
+              name: noteTools[nti].name,
+              description: noteTools[nti].description || noteTools[nti].name,
+              inputSchema: normalizeToolSchema(noteTools[nti].inputSchema),
             });
           }
         }
 
-        if (pairOnly) return Promise.resolve(tools);
+        if (sessionOnly) return Promise.resolve(tools);
 
         // In-app MCP servers (debate, browser, email).
         // Use getLocalMcpServers() so clay-browser is hidden unless the
@@ -1461,7 +1519,15 @@ function createProjectContext(opts) {
             }
           }
         }
-        if (pairOnly) return Promise.reject(new Error("Pair tool not found: " + toolName));
+        if (boundSession && serverName === "clay-notes") {
+          var noteTools = _sessionNotes.getToolDefs(boundSession);
+          for (var nti = 0; nti < noteTools.length; nti++) {
+            if (noteTools[nti].name === toolName && typeof noteTools[nti].handler === "function") {
+              return Promise.resolve(noteTools[nti].handler(args || {}));
+            }
+          }
+        }
+        if (sessionOnly) return Promise.reject(new Error("Session tool not found: " + serverName + "/" + toolName));
         // Try in-app servers first (gated by extension connectivity for clay-browser).
         var localMcp = getLocalMcpServers();
         if (localMcp && localMcp[serverName]) {

package/lib/public/app.js

@@ -42,7 +42,6 @@ import { initProfile, getProfileLang } from './modules/profile.js';
 import { initUserSettings } from './modules/user-settings.js';
 import { initToolPalettes } from './modules/tool-palette.js';
 import { initProjectSwitcher } from './modules/project-switcher.js';
-import { initBranchSwitcher } from './modules/branch-switcher.js';
 import { initSplitView } from './modules/split-view.js';
 import { initPaneBridge } from './modules/pane-bridge.js';
 import { initAdmin, checkAdminAccess } from './modules/admin.js';
@@ -97,6 +96,7 @@ import { initDebate, handleDebatePreparing, handleDebateStarted, handleDebateRes
   var sendBtn = $("send-btn");
   function getStatusDot() {
     return document.querySelector("#icon-strip-projects .icon-strip-item.active .icon-strip-status") ||
+           document.querySelector("#icon-strip-projects .icon-strip-wt-item.active .icon-strip-status") ||
            document.querySelector("#icon-strip-users .icon-strip-mate.active .icon-strip-status");
   }
   var headerTitleEl = $("header-title");
@@ -287,8 +287,6 @@ import { initDebate, handleDebatePreparing, handleDebateStarted, handleDebateRes
     projectName: projectName,
     cwd: "",
     currentSlug: currentSlug,
-    projects: [],
-    homeHubVisible: false,
     currentProjectOwnerId: null,
     isOsUsers: false,
     skipPermsEnabled: false,
@@ -481,7 +479,6 @@ import { initDebate, handleDebatePreparing, handleDebateStarted, handleDebateRes
   // keydown listener registers later — capture-phase ordering doesn't
   // matter here but it keeps related bootstrap steps adjacent.
   initProjectSwitcher();
-  initBranchSwitcher();
   initSplitView();
   initPaneBridge();
 

package/lib/public/css/icon-strip.css

@@ -223,6 +223,7 @@
 
 /* Show dot only on active item or when processing */
 .icon-strip-item.active .icon-strip-status,
+.icon-strip-wt-item.active .icon-strip-status,
 .icon-strip-status.processing {
   opacity: 1;
 }
@@ -247,6 +248,7 @@
 
 /* Pending permission shake */
 .icon-strip-item.has-pending-perm,
+.icon-strip-wt-item.has-pending-perm,
 .icon-strip-mate.has-pending-perm {
   animation: permShake 2s ease-in-out infinite;
 }
@@ -1144,6 +1146,155 @@
   opacity: 1;
 }
 
+/* --- Worktree folder groups --- */
+.icon-strip-group {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  position: relative;
+}
+
+.icon-strip-group .folder-header {
+  position: relative;
+}
+
+.icon-strip-group-chevron {
+  position: absolute;
+  bottom: 2px;
+  right: 2px;
+  width: 16px;
+  height: 16px;
+  border-radius: 50%;
+  background: var(--bg-alt);
+  border: 1px solid var(--border);
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  color: var(--text-dimmer);
+  pointer-events: auto;
+  cursor: pointer;
+  transition: transform 0.15s ease, background 0.15s, border-color 0.15s;
+  z-index: 2;
+  line-height: 1;
+}
+
+.icon-strip-group-chevron i,
+.icon-strip-group-chevron svg {
+  width: 10px;
+  height: 10px;
+}
+
+.icon-strip-group-chevron:hover {
+  background: var(--bg-hover, var(--bg-alt));
+  border-color: var(--text-dimmer);
+  color: var(--text-secondary);
+}
+
+.icon-strip-group.collapsed .icon-strip-group-chevron {
+  background: var(--border);
+}
+
+.icon-strip-group-items {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  overflow: hidden;
+  transition: max-height 0.2s ease;
+  max-height: 500px;
+  border-left: 2px solid var(--border);
+  margin-left: 0;
+  padding-left: 0;
+}
+
+.icon-strip-group.collapsed .icon-strip-group-items {
+  max-height: 0;
+}
+
+/* Worktree items (smaller than regular project icons) */
+.icon-strip-wt-item {
+  width: 48px;
+  height: 40px;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  cursor: pointer;
+  position: relative;
+  text-decoration: none;
+  color: var(--text-secondary);
+  transition: background 0.15s;
+}
+
+.icon-strip-wt-item::before {
+  content: "";
+  position: absolute;
+  width: 30px;
+  height: 30px;
+  border-radius: 8px;
+  background: var(--bg-alt);
+  opacity: 0.7;
+  transition: opacity 0.15s, background 0.15s;
+}
+
+.icon-strip-wt-item:hover::before {
+  opacity: 1;
+}
+
+.icon-strip-wt-item.active::before {
+  background: var(--accent);
+  opacity: 1;
+}
+
+.icon-strip-wt-item.active {
+  color: #fff;
+}
+
+.icon-strip-wt-item .wt-branch-abbrev {
+  font-size: 11px;
+  font-weight: 600;
+  letter-spacing: -0.5px;
+  pointer-events: none;
+  position: relative;
+  z-index: 1;
+}
+
+/* Disabled/inaccessible worktree */
+.icon-strip-wt-item.wt-disabled {
+  opacity: 0.35;
+  cursor: not-allowed;
+}
+
+.icon-strip-wt-item.wt-disabled::after {
+  content: "\1F6AB";
+  position: absolute;
+  font-size: 14px;
+  z-index: 3;
+  filter: grayscale(0.3);
+}
+
+/* Group add button */
+.icon-strip-group-add {
+  width: 30px;
+  height: 30px;
+  border-radius: 8px;
+  border: 1.5px dashed var(--border);
+  background: transparent;
+  color: var(--text-dimmer);
+  font-size: 16px;
+  font-weight: 400;
+  cursor: pointer;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  margin: 2px 0 4px 0;
+  transition: border-color 0.15s, color 0.15s, background 0.15s;
+}
+
+.icon-strip-group-add:hover {
+  border-color: var(--accent);
+  color: var(--accent);
+  background: rgba(var(--accent-rgb, 124, 58, 237), 0.08);
+}
+
 /* --- Worktree creation modal --- */
 .wt-modal-overlay {
   position: fixed;
@@ -1258,6 +1409,45 @@ select.wt-modal-input {
   cursor: not-allowed;
 }
 
+/* --- Mobile worktree folder --- */
+.mobile-project-folder {
+  display: flex;
+  flex-direction: column;
+}
+
+.mobile-project-item.wt-item {
+  padding-left: 28px;
+  opacity: 0.85;
+}
+
+.mobile-project-item.wt-disabled {
+  opacity: 0.35;
+  cursor: not-allowed;
+}
+
+.mobile-folder-chevron {
+  font-size: 8px;
+  color: var(--text-dimmer);
+  margin-left: auto;
+  cursor: pointer;
+  transition: transform 0.15s ease;
+  padding: 4px;
+}
+
+.mobile-project-folder.collapsed .mobile-folder-chevron {
+  transform: rotate(-90deg);
+}
+
+.mobile-folder-items {
+  overflow: hidden;
+  transition: max-height 0.2s ease;
+  max-height: 500px;
+}
+
+.mobile-project-folder.collapsed .mobile-folder-items {
+  max-height: 0;
+}
+
 /* --- Per-project presence avatars --- */
 /* --- Mobile: hide icon strip --- */
 /* --- Skeleton loading placeholders --- */