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

package/lib/public/style.css

@@ -79,6 +79,7 @@
 @import url("css/skills-workbench.css");
 
 @import url("css/right-workbench.css?v=20261020-workbench-overlay");
+@import url("css/tool-pane.css");
 
 @import url("css/mate-conversation.css");
 

package/lib/sdk-message-processor.js

@@ -229,7 +229,8 @@ function attachMessageProcessor(ctx) {
       // 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: [] });
+      session.backgroundTaskCatalog = null;
+      sendToSession(session, { type: "active_background_tasks", tasks: [], catalog: [] });
       if (previousBackgroundTaskCount !== 0) sm.broadcastSessionList();
       var fsSkills = discoverSkillDirs(getSessionSkillOptions(session));
       session.skillNames = Array.from(mergeSkills(parsed.skills, fsSkills));
@@ -463,6 +464,7 @@ function attachMessageProcessor(ctx) {
 
     } else if (parsed.yokeType === "subagent_message") {
       // Sub-agent messages: extract tool_use blocks for activity display
+      require("./project-background-tasks").observeMessage(session, parsed, sendToSession);
       processSubagentMessage(session, parsed);
 
     } else if (parsed.yokeType === "message") {
@@ -864,7 +866,8 @@ function attachMessageProcessor(ctx) {
         Array.isArray(parsed.tasks) ? parsed.tasks : []
       );
       session.activeBackgroundTasks = activeBackgroundTasks;
-      sendToSession(session, { type: "active_background_tasks", tasks: activeBackgroundTasks });
+      var taskCatalog = require("./project-background-tasks").remember(session, activeBackgroundTasks);
+      sendToSession(session, { type: "active_background_tasks", tasks: activeBackgroundTasks, catalog: taskCatalog });
       if (previousBackgroundTaskCount !== backgroundTaskTiming.countUserTasks(activeBackgroundTasks)) {
         sm.broadcastSessionList();
       }

package/lib/server-storage.js

@@ -6,6 +6,21 @@ function attachStorage(ctx) {
   var progress = null;
   var expires = 0;
   var failed = false;
+  var scanIdentity = null;
+  function projectIdentity() {
+    return JSON.stringify((ctx.getProjects ? ctx.getProjects() : []).map(function (project) { return [project.slug, project.path, project.projectOwnerId, project.isMate]; }));
+  }
+  function targetProject(slug) {
+    return (ctx.getProjects ? ctx.getProjects() : []).find(function (project) { return project.slug === slug && !project.isMate && !/^mate-/.test(slug); });
+  }
+  function usageReply(req, res, result, slug) {
+    if (!authorized(req, res)) return;
+    if (!slug) { reply(res, result.scanning ? 202 : 200, result); return; }
+    if (!targetProject(slug)) { reply(res, 404, { error: 'Project is no longer registered.' }); return; }
+    if (scanIdentity !== projectIdentity()) { reply(res, 409, { error: 'Project registration changed. Refresh usage.' }); return; }
+    var usage = (result.projects || []).find(function (project) { return project.slug === slug; });
+    reply(res, result.scanning ? 202 : 200, { slug: slug, scanning: !!result.scanning, partial: !!result.partial, checkedAt: result.checkedAt || null, usage: usage || null });
+  }
   function reply(res, status, data) {
     res.writeHead(status, { 'Content-Type': 'application/json', 'Cache-Control': 'no-store' });
     res.end(JSON.stringify(data));
@@ -19,14 +34,23 @@ function attachStorage(ctx) {
     return true;
   }
   function handleRequest(req, res, url) {
-    if (url.split('?')[0] !== '/api/server/storage') return false;
+    var pathname = url.split('?')[0];
+    var match = /^\/api\/server\/storage\/project\/([^/]+)$/.exec(pathname);
+    if (pathname !== '/api/server/storage' && !match) return false;
+    var slug = null;
     var refresh = new URL(url, 'http://localhost').searchParams.get('refresh') === '1';
     if (!authorized(req, res)) return true;
     if (req.method !== 'GET') { reply(res, 405, { error: 'Method not allowed.' }); return true; }
+    if (match) {
+      try { slug = decodeURIComponent(match[1]); } catch (error) { reply(res, 400, { error: 'Invalid project.' }); return true; }
+      if (!targetProject(slug)) { reply(res, 404, { error: 'Project not found.' }); return true; }
+    }
+    if (!pending && scanIdentity !== projectIdentity()) { cached = null; failed = false; }
     if (failed && Date.now() < expires) { reply(res, 500, { error: 'Disk usage could not be measured. Try again in a few seconds.' }); return true; }
-    if (!pending && !refresh && cached && Date.now() < expires) { reply(res, 200, cached); return true; }
+    if (!pending && !refresh && cached && Date.now() < expires) { usageReply(req, res, cached, slug); return true; }
     if (!pending) {
       progress = null; failed = false;
+      scanIdentity = projectIdentity();
       var users = ctx.users.getAllUsers();
       var projects = ctx.getProjects ? ctx.getProjects() : [];
       if (!ctx.users.isMultiUser() && users.length <= 1) {
@@ -45,7 +69,7 @@ function attachStorage(ctx) {
       timer = setTimeout(function () { resolve(progress || { scanning: true }); }, 750);
     })]).then(function (result) {
       clearTimeout(timer);
-      if (!res.destroyed && authorized(req, res)) reply(res, result.scanning ? 202 : 200, result);
+      if (!res.destroyed) usageReply(req, res, result, slug);
     }).catch(function () {
       clearTimeout(timer);
       if (!res.destroyed) reply(res, 500, { error: 'Disk usage could not be measured. Try refreshing.' });

package/lib/server-workbench-layout-settings.js

@@ -32,7 +32,7 @@ function attachWorkbenchLayoutSettings(ctx) {
     req.on('data', function (chunk) {
       if (finished) return;
       body += chunk;
-      if (Buffer.byteLength(body) > 1024) { finished = true; body = ''; reply(res, 413, { error: 'Request too large.' }); }
+      if (Buffer.byteLength(body) > 65536) { finished = true; body = ''; reply(res, 413, { error: 'Request too large.' }); }
     });
     req.on('aborted', function () { finished = true; });
     req.on('error', function () { finished = true; });
@@ -41,11 +41,11 @@ function attachWorkbenchLayoutSettings(ctx) {
       if (identity(req) !== accountId) { reply(res, 401, { error: 'Account changed. Sign in again.' }); return; }
       var input;
       try { input = JSON.parse(body); } catch (error) { reply(res, 400, { error: 'Invalid JSON.' }); return; }
-      if (!input || Array.isArray(input) || Object.keys(input).length !== 2 || !Object.prototype.hasOwnProperty.call(input, 'mode') || !Object.prototype.hasOwnProperty.call(input, 'revision')) {
+      if (!input || Array.isArray(input) || Object.keys(input).some(function (key) { return ['mode', 'revision', 'layout'].indexOf(key) < 0; }) || !Object.prototype.hasOwnProperty.call(input, 'mode') || !Object.prototype.hasOwnProperty.call(input, 'revision')) {
         reply(res, 400, { error: 'Invalid workbench preference.' }); return;
       }
       try {
-        var result = ctx.users.setWorkbenchLayoutPreference(accountId, input.mode, input.revision);
+        var result = ctx.users.setWorkbenchLayoutPreference(accountId, input.mode, input.revision, input.layout);
         reply(res, result.error ? result.status || 400 : 200, result);
       } catch (error) { reply(res, 500, { error: 'Workbench layout could not be saved. Your previous layout is retained.' }); }
     });

package/lib/server.js

@@ -519,7 +519,7 @@ function createServer(opts) {
     } : null;
     var payload = JSON.stringify(seed).replace(/</g, "\\u003c").replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
     var script = '<script>window.__clayAppearanceSeed=' + payload + ';</script>';
-    return html.replace('<script src="appearance-bootstrap.js"></script>', script + '<script src="appearance-bootstrap.js"></script>');
+    return html.replace(/<script src="\/?appearance-bootstrap.js"><\/script>/, function (tag) { return script + tag; });
   }
 
   function sendAppShell(req, res, slug) {
@@ -1103,8 +1103,10 @@ function createServer(opts) {
       if (!httpUser || !canUserAccessSlug(httpUser.id, slug)) {
         var overview = httpUser && administrativeMetadata(httpUser.id, slug);
         if (overview && req.method === "GET" && (projectUrlForAuth === "/" || projectUrlForAuth === "/index.html")) {
+          var overviewAppearance = null;
+          try { overviewAppearance = settings.getInitialAppearance(req); } catch (error) {}
           res.writeHead(200, { "Content-Type": "text/html; charset=utf-8", "Cache-Control": "no-store" });
-          res.end(projectAdminOverview.page(overview, getVisibleProjects(httpUser.id)));
+          res.end(injectAppearanceSeed(projectAdminOverview.page(overview, getVisibleProjects(httpUser.id)), overviewAppearance));
           return;
         }
         res.writeHead(403, { "Content-Type": "application/json", "Cache-Control": "no-store" });

package/lib/sessions.js

@@ -886,7 +886,7 @@ function createSessionManager(opts) {
     if (session.isProcessing) {
       _send({ type: "status", status: "processing" });
     }
-    _send({ type: "active_background_tasks", tasks: session.activeBackgroundTasks || [] });
+    _send({ type: "active_background_tasks", tasks: session.activeBackgroundTasks || [], catalog: session.backgroundTaskCatalog && session.backgroundTaskCatalog.tasks || [] });
 
     // Re-send any pending permission requests
     var pendingIds = Object.keys(session.pendingPermissions);

package/lib/split-view-layout.js

@@ -12,7 +12,7 @@ function validateTree(tree, expectedOrigins) {
   var invalid = null;
   function walk(node, depth) {
     if (invalid) return;
-    if (!node || typeof node !== "object" || depth > MAX_SESSIONS) { invalid = "Layout tree is malformed"; return; }
+    if (!node || typeof node !== "object" || Array.isArray(node) || depth > MAX_SESSIONS) { invalid = "Layout tree is malformed"; return; }
     if (Object.prototype.hasOwnProperty.call(node, "id")) {
       if (Object.keys(node).length !== 1 || !validOrigin(node.id) || origins.indexOf(node.id) !== -1) {
         invalid = "Layout leaves must have unique valid session origins"; return;
@@ -28,11 +28,11 @@ function validateTree(tree, expectedOrigins) {
     }
     walk(node.left, depth + 1); walk(node.right, depth + 1);
   }
-  walk(tree, 0);
+  if (tree !== null) walk(tree, 0);
   if (invalid) return { ok: false, error: invalid, origins: origins };
-  if (origins.length < 2 || origins.length > MAX_SESSIONS) return { ok: false, error: "A Split view requires two to eight sessions", origins: origins };
+  if (origins.length > MAX_SESSIONS) return { ok: false, error: "A View supports zero to eight sessions", origins: origins };
   if (expectedOrigins) {
-    if (!Array.isArray(expectedOrigins) || expectedOrigins.length !== origins.length ||
+    if (!Array.isArray(expectedOrigins) || expectedOrigins.length !== origins.length || new Set(expectedOrigins).size !== expectedOrigins.length ||
         expectedOrigins.some(function (id) { return !validOrigin(id) || origins.indexOf(id) === -1; })) {
       return { ok: false, error: "Layout leaves must exactly match the selected sessions", origins: origins };
     }
@@ -100,9 +100,9 @@ function validateViewShape(view) {
   var name = validateName(view.name);
   if (!name.ok) return name;
   if (view.nameMode != null && ["automatic", "custom"].indexOf(view.nameMode) === -1) return { ok: false, error: "Split view name mode is invalid" };
-  if (!Number.isInteger(view.revision) || view.revision < 1 || !validatePreset(view.layout)) return { ok: false, error: "Split view revision or layout is invalid" };
+  if (!Number.isSafeInteger(view.revision) || view.revision < 1 || !validatePreset(view.layout)) return { ok: false, error: "Split view revision or layout is invalid" };
   var refs = view.sessionRefs;
-  if (!Array.isArray(refs) || refs.length < 2 || refs.length > MAX_SESSIONS) return { ok: false, error: "A Split view requires two to eight sessions" };
+  if (!Array.isArray(refs) || refs.length > MAX_SESSIONS) return { ok: false, error: "A View supports zero to eight sessions" };
   var ids = [];
   for (var i = 0; i < refs.length; i++) {
     var ref = refs[i];
@@ -113,7 +113,11 @@ function validateViewShape(view) {
   }
   var tree = validateTree(view.tree, ids);
   if (!tree.ok) return tree;
-  if (typeof view.activeSessionOriginId !== "string" || ids.indexOf(view.activeSessionOriginId) === -1) return { ok: false, error: "Active session must belong to the Split view" };
+  if (ids.length ? typeof view.activeSessionOriginId !== "string" || ids.indexOf(view.activeSessionOriginId) === -1 : view.activeSessionOriginId !== null) return { ok: false, error: "Active session must belong to the Split view" };
+  if (view.workspace !== undefined) {
+    var checked = require("./project-view-workspace").validate(view.workspace, view);
+    if (!checked.ok) return checked;
+  }
   return { ok: true, name: name.name, origins: ids };
 }
 

package/lib/storage-usage.js

@@ -39,10 +39,26 @@ async function scanStorage(options) {
     if (identity && !owners.get(identity.uid)) rows[index].mapped = false;
   });
   var projectRoots = new Map();
+  var projectUsage = [];
+  var usageRoots = new Map();
   var projectErrors = 0;
   for (var project of projects) {
+    var usage = { slug: project.slug, available: false, bytes: 0, files: 0, capacityBytes: null, availableBytes: null };
+    if (!project.isMate && project.slug) projectUsage.push(usage);
     try {
       var projectPath = await fs.realpath(project.path);
+      usage.available = true;
+      if (usageRoots.has(projectPath)) {
+        var priorUsage = usageRoots.get(projectPath);
+        if (priorUsage) priorUsage.available = false;
+        usage.available = false;
+        usageRoots.set(projectPath, null);
+      } else usageRoots.set(projectPath, project.isMate ? null : usage);
+      try {
+        var volume = await fs.statfs(projectPath);
+        usage.capacityBytes = volume.blocks * volume.bsize;
+        usage.availableBytes = volume.bavail * volume.bsize;
+      } catch (error) { /* Volume capacity can be unavailable independently of allocation. */ }
       var row = rows.find(function (item) { return item.id === project.projectOwnerId; }) || null;
       if (row) row.projects++;
       if (projectRoots.has(projectPath) && projectRoots.get(projectPath) !== row) row = null;
@@ -50,21 +66,20 @@ async function scanStorage(options) {
     } catch (error) { projectErrors++; }
   }
   var orderedProjects = Array.from(projectRoots.keys()).sort(function (a, b) { return b.length - a.length; });
-  function projectOwner(filePath) {
-    var root = orderedProjects.find(function (candidate) { return filePath === candidate || filePath.indexOf(candidate + path.sep) === 0; });
-    return root ? projectRoots.get(root) : null;
+  function projectRoot(filePath) {
+    return orderedProjects.find(function (candidate) { return filePath === candidate || filePath.indexOf(candidate + path.sep) === 0; });
   }
   var roots = orderedProjects.concat(options.projectPaths || []);
   identities.forEach(function (identity) { if (identity) roots.push(identity.home); });
   roots.push(options.configDir);
-  var report = { attribution: projectMode ? "project" : "filesystem", users: rows, totalBytes: 0, totalFiles: 0, unattributedBytes: 0, unattributedFiles: 0,
+  var report = { attribution: projectMode ? "project" : "filesystem", users: rows, projects: projectUsage, totalBytes: 0, totalFiles: 0, unattributedBytes: 0, unattributedFiles: 0,
     partial: false, errors: projectErrors + users.filter(function (user, index) { return !projectMode && options.platform === 'linux' && user.linuxUser && !identities[index]; }).length, skippedLinks: 0, skippedMounts: 0, scannedEntries: 0, roots: 0, platform: options.platform };
   var lastProgress = 0;
   function progress() {
     if (!options.onProgress || Date.now() - lastProgress < 500) return;
     lastProgress = Date.now();
     options.onProgress(Object.assign({}, report, { scanning: true, checkedAt: new Date().toISOString(),
-      users: rows.map(function (row) { return Object.assign({}, row); }) }));
+      users: rows.map(function (row) { return Object.assign({}, row); }), projects: projectUsage.map(function (row) { return Object.assign({}, row); }) }));
   }
   progress();
   var seen = new Map();
@@ -118,9 +133,15 @@ async function scanStorage(options) {
     if (stat.isSymbolicLink()) { report.skippedLinks++; return; }
     if (stat.dev !== device) { report.skippedMounts++; return; }
     var key = stat.dev + ':' + stat.ino;
-    var owner = projectMode ? projectOwner(filePath) : owners.get(stat.uid);
+    var usageRoot = projectRoot(filePath);
+    var owner = projectMode ? projectRoots.get(usageRoot) : owners.get(stat.uid);
+    var usage = usageRoot && usageRoots.get(usageRoot);
     if (seen.has(key)) {
       var previous = seen.get(key);
+      if (stat.isFile() && previous.project && usage && previous.project !== usage) {
+        previous.project.bytes -= previous.bytes; previous.project.files--;
+        previous.project = null;
+      }
       if (projectMode && stat.isFile() && previous.owner && previous.owner !== owner) {
         previous.owner.bytes -= previous.bytes; previous.owner.files--;
         report.unattributedBytes += previous.bytes; report.unattributedFiles++;
@@ -132,7 +153,8 @@ async function scanStorage(options) {
     if (!stat.isDirectory() && !stat.isFile()) return;
     var bytes = typeof stat.blocks === 'number' ? stat.blocks * 512 : stat.size;
     // Only directories and multiply-linked files need identity deduplication.
-    if (stat.isDirectory() || stat.nlink > 1) seen.set(key, { owner: owner, bytes: bytes });
+    if (stat.isDirectory() || stat.nlink > 1) seen.set(key, { owner: owner, project: usage, bytes: bytes });
+    if (usage) { usage.bytes += bytes; if (stat.isFile()) usage.files++; }
     report.totalBytes += bytes;
     if (stat.isFile()) report.totalFiles++;
     if (owner) { owner.bytes += bytes; if (stat.isFile()) owner.files++; }

package/lib/terminal-manager.js

@@ -136,9 +136,9 @@ function createTerminalManager(opts) {
       sendTo(ws, { type: "term_output", id: id, data: replay });
     }
 
-    // Send current terminal dimensions so the client renders at the correct size
+    // This snapshot may arrive after the attaching client has fitted a new viewport.
     if (!alreadySubscribed && session.cols && session.rows) {
-      sendTo(ws, { type: "term_resized", id: id, cols: session.cols, rows: session.rows });
+      sendTo(ws, { type: "term_resized", id: id, cols: session.cols, rows: session.rows, initial: true });
     }
 
     // If already exited, notify

package/lib/users-workbench-layout-preferences.js

@@ -1,3 +1,4 @@
+var windowLayouts = require('./workbench-window-layout');
 // Account UI preferences are excluded from canonical Clay controls.
 function validMode(mode) { return mode === 'overlay' || mode === 'docked'; }
 function attachWorkbenchLayoutPreferences(deps) {
@@ -12,16 +13,25 @@ function attachWorkbenchLayoutPreferences(deps) {
   function value(accountId, saved) {
     if (saved === undefined) return { accountId: accountId, mode: 'overlay', revision: 0 };
     if (!saved || !validMode(saved.mode) || !Number.isSafeInteger(saved.revision) || saved.revision < 1) throw new Error('Invalid stored preference.');
-    return { accountId: accountId, mode: saved.mode, revision: saved.revision };
+    if (saved.layouts && !windowLayouts.validLayouts(saved.layouts)) throw new Error('Invalid stored window layout.');
+    return Object.assign({ accountId: accountId, mode: saved.mode, revision: saved.revision }, saved.layouts ? { layouts: saved.layouts } : {});
   }
   function get(accountId) { return value(accountId, context(accountId).saved); }
-  function set(accountId, mode, revision) {
+  function set(accountId, mode, revision, layout) {
+    if (layout !== undefined && !windowLayouts.validLayout(layout)) return { status: 400, error: 'Invalid window layout.' };
     if (!validMode(mode) || !Number.isSafeInteger(revision) || revision < 0) return { status: 400, error: 'Invalid workbench layout.' };
     var current = context(accountId), prior = value(accountId, current.saved);
     if (prior.revision !== revision) return { status: 409, error: 'Workbench layout changed elsewhere. Reload the preference and try again.' };
-    if (prior.mode === mode) return prior;
+    var layouts = Object.assign({}, prior.layouts || {});
+    var changed = layout && JSON.stringify(layouts[layout.key]) !== JSON.stringify({ base: layout.base, tree: layout.tree });
+    if (prior.mode === mode && !changed) return prior;
+    if (layout) {
+      delete layouts[layout.key];
+      if (Object.keys(layouts).length >= 32) delete layouts[Object.keys(layouts)[0]];
+      layouts[layout.key] = { base: layout.base, tree: layout.tree };
+    }
     if (revision === Number.MAX_SAFE_INTEGER) throw new Error('Preference revision exhausted.');
-    var saved = { mode: mode, revision: revision + 1 };
+    var saved = Object.assign({ mode: mode, revision: revision + 1 }, Object.keys(layouts).length ? { layouts: layouts } : {});
     if (current.settings) config.saveConfig(Object.assign({}, current.settings, { workbenchLayoutPreference: saved }));
     else deps.saveUsers(Object.assign({}, current.data, { users: current.data.users.map(function (entry) {
       return entry === current.user ? Object.assign({}, entry, { workbenchLayoutPreference: saved }) : entry;

package/lib/workbench-window-layout.js

@@ -0,0 +1,30 @@
+// Display preferences only: these records never open sessions or run tools.
+var tools = ['tool-terminal', 'tool-browser', 'tool-file-viewer'];
+function validTree(tree, allowTools) {
+  var ids = [], nodes = 0;
+  function walk(node, depth) {
+    if (!node || typeof node !== 'object' || Array.isArray(node) || ++nodes > 21 || depth > 10) return false;
+    if (Object.prototype.hasOwnProperty.call(node, 'id')) {
+      if (Object.keys(node).length !== 1 || typeof node.id !== 'string' || !/^[A-Za-z0-9_-]{1,128}$/.test(node.id)) return false;
+      if (node.id.indexOf('tool-') === 0 && (!allowTools || tools.indexOf(node.id) < 0)) return false;
+      ids.push(node.id); return true;
+    }
+    return Object.keys(node).sort().join(',') === 'axis,left,ratio,right' && ['horizontal', 'vertical'].indexOf(node.axis) >= 0 &&
+      Number.isFinite(node.ratio) && node.ratio >= .05 && node.ratio <= .95 && walk(node.left, depth + 1) && walk(node.right, depth + 1);
+  }
+  return walk(tree, 0) && ids.length > 0 && ids.length <= (allowTools ? 11 : 8) && new Set(ids).size === ids.length;
+}
+function validLayout(input) {
+  return !!input && typeof input === 'object' && !Array.isArray(input) && Object.keys(input).sort().join(',') === 'base,key,tree' &&
+    typeof input.key === 'string' && input.key.length > 0 && input.key.length <= 512 && input.key !== '__proto__' &&
+    validTree(input.base, false) && validTree(input.tree, true) && sameSessions(input.base, input.tree);
+}
+function sameSessions(base, tree) {
+  function ids(node) { return node.id ? (tools.indexOf(node.id) >= 0 ? [] : [node.id]) : ids(node.left).concat(ids(node.right)); }
+  return JSON.stringify(ids(base).sort()) === JSON.stringify(ids(tree).sort());
+}
+function validLayouts(layouts) {
+  return !!layouts && typeof layouts === 'object' && !Array.isArray(layouts) && Object.keys(layouts).length <= 32 &&
+    Object.keys(layouts).every(function (key) { var item = layouts[key]; return item && validLayout({ key: key, base: item.base, tree: item.tree }); });
+}
+module.exports = { validLayout: validLayout, validLayouts: validLayouts };

package/lib/worker-message-previews.js

@@ -0,0 +1,50 @@
+// Bounded, exact-owner message previews use the Worker reader's existing authority.
+function latest(history) {
+  var found = null;
+  for (var i = history.length - 1, stop = Math.max(0, history.length - 1000); i >= stop; i--) {
+    var entry = history[i];
+    if (entry && (entry.type === 'delta' || entry.type === 'assistant_message') && typeof entry.text === 'string' && entry.text.trim()) {
+      var index = i, text = entry.text;
+      while (index > stop && history[index - 1].type === 'delta' && entry.type === 'delta' ) { index--; text = (history[index].text + text).slice(0, 1200); }
+      found = { id: String(index), text: text.slice(0, 1200), timestamp: history[index]._ts || null }; break;
+    }
+  }
+  return found;
+}
+function attach(ctx) {
+  var subscriptions = new WeakMap();
+  function release(ws) {
+    var old = subscriptions.get(ws); if (!old) return;
+    subscriptions.delete(ws); old.entries.forEach(function (entry) { clearTimeout(entry.timer); if (entry.release) entry.release(); });
+    if (ws.removeListener) ws.removeListener('close', old.close);
+  }
+  function handleMessage(ws, msg) {
+    if (msg.type !== 'split_worker_preview_request') return false;
+    release(ws);
+    if (typeof msg.requestId !== 'string' || msg.requestId.length > 160 || !Array.isArray(msg.targets) || msg.targets.length > 32) return true;
+    var state = { entries: [], close: function () { release(ws); } }; subscriptions.set(ws, state);
+    msg.targets.forEach(function (target) {
+      var pair = ctx.resolve(ws, target); if (!pair || state.entries.some(function (entry) { return entry.worker === pair.worker; })) return;
+      var entry = { worker: pair.worker, timer: null, last: null };
+      function send(live) {
+        var current = ctx.resolve(ws, target);
+        if (subscriptions.get(ws) !== state || ws.readyState !== 1 || !current || current.driver !== pair.driver || current.worker !== pair.worker) { if (entry.release) entry.release(); return; }
+        var preview = latest(pair.worker.history || []); if (!preview) return;
+        preview.vendor = pair.worker.vendor || null;
+        if (entry.last === JSON.stringify(preview)) return;
+        entry.last = JSON.stringify(preview);
+        ctx.send(ws, { type: 'split_worker_message_preview', requestId: msg.requestId, parentSessionOriginId: target.parentSessionOriginId,
+          workerSessionOriginId: target.workerSessionOriginId, generation: target.generation, live: live, preview: preview });
+      }
+      entry.release = ctx.sm.subscribeSession(pair.worker.localId, function (event) {
+        if (!event || ['delta', 'assistant_message'].indexOf(event.type) < 0 || entry.timer) return;
+        entry.timer = setTimeout(function () { entry.timer = null; send(true); }, 60);
+      });
+      state.entries.push(entry); send(false);
+    });
+    if (ws.once) ws.once('close', state.close);
+    return true;
+  }
+  return { handleMessage: handleMessage };
+}
+module.exports = { attach: attach, latest: latest };

package/lib/ws-schema.js

@@ -24,7 +24,7 @@ var schema = {
   "switch_session":           { direction: "c2s", handler: "lib/project-sessions.js", description: "Switch the active session by local ID" },
   "resume_tui_session":       { direction: "c2s", handler: "lib/project-sessions.js", description: "Spawn the claude --resume PTY for a TUI session shown read-only (lazy resume)" },
   "suspend_tui_session":      { direction: "c2s", handler: "lib/project-sessions.js", description: "Close a live TUI session's PTY now but keep it resumable (explicit Close)" },
-  "new_session":              { direction: "c2s", handler: "lib/project-sessions.js", description: "Create a new blank session (opts: vendor, mode, sessionVisibility, dangerouslySkipPermissions)" },
+  "new_session":              { direction: "c2s", handler: "lib/project-sessions.js", description: "Create a blank session; correlated ordinary-project requests may use activate:false to preserve the current View selection" },
   "new_session_result":       { direction: "s2c", handler: "lib/public/modules/scheduled-tasks.js", description: "Correlated result for a requested new session" },
   "delete_session":           { direction: "c2s", handler: "lib/project-sessions.js", description: "Delete a session by ID" },
   "rename_session":           { direction: "c2s", handler: "lib/project-sessions.js", description: "Rename a session" },

package/lib/yoke/adapters/claude-worker.js

@@ -97,6 +97,8 @@ function applyWorkerClaudeBinary(options) {
 // --- State ---
 var sdkModule = null;
 var queryInstance = null;
+var taskReader = null;
+var taskReaderModule = require("../claude-task-reader");
 var messageQueue = null;
 var abortController = null;
 var pendingPermissions = {};  // requestId -> resolve
@@ -284,6 +286,9 @@ function handleMessage(msg) {
     case "set_permission_mode":
       handleSetPermissionMode(msg);
       break;
+    case "read_background_task":
+      taskReaderModule.respond(taskReader, msg, sendToDaemon);
+      break;
     case "stop_task":
       handleStopTask(msg);
       break;
@@ -598,6 +603,8 @@ async function handleQueryStart(msg) {
       prompt: messageQueue,
       options: options,
     });
+    if (taskReader) taskReader.close();
+    taskReader = taskReaderModule.createReader(getSDK, function () { return queryInstance; }, options.cwd);
     perf("query instance created");
   } catch (e) {
     sendToDaemon({ type: "query_error", error: "Failed to create query: " + (e.message || e), exitCode: null, stderr: null });
@@ -618,6 +625,7 @@ async function handleQueryStart(msg) {
     var firstText = true;
     var eventCounts = {};
     for await (var event of queryInstance) {
+      taskReader.observe(event);
       var etype = (event && event.type || "?");
       var esubtype = (event && event.subtype || "");
       eventCounts[etype] = (eventCounts[etype] || 0) + 1;

package/lib/yoke/adapters/claude.js

@@ -18,6 +18,7 @@ var claudeUserInput = require("../claude-user-input");
 var claudeCorrelation = require("../claude-message-correlation");
 var claudeContextUsage = require("../claude-context-usage");
 var claudeModelSwitch = require("../claude-model-switch");
+var taskReaderModule = require("../claude-task-reader");
 
 // SDK-specific knowledge stays in the adapter (not the relay): the host dialog
 // kinds this client can render, declared to the SDK when an onUserDialog
@@ -580,6 +581,8 @@ function normalizeBackgroundTasks(tasks) {
       task_id: task && task.task_id,
       task_type: taskType,
       description: (task && task.description) || "",
+      run_id: task && task.run_id || null,
+      parent_task_id: task && task.parent_task_id || null,
       // Housekeeping the CLI does not surface as user work (skip_transcript
       // tasks, auto-started live-update watchers). Clay keeps these out of its
       // activity indicators and lists them as a subdued secondary group.
@@ -597,7 +600,8 @@ function normalizeBackgroundTasks(tasks) {
 // --- QueryHandle ---
 // Wraps a raw SDK query object with the YOKE QueryHandle interface.
 // Events are flattened via flattenEvent before yielding.
-function createQueryHandle(rawQuery, messageQueue, abortController) {
+function createQueryHandle(rawQuery, messageQueue, abortController, cwd) {
+  var taskReader = taskReaderModule.createReader(loadSDK, function () { return closed ? null : rawQuery; }, cwd);
   var correlation = claudeCorrelation.createCorrelation();
   var closed = false;
   var removeAbort = function () {};
@@ -615,6 +619,7 @@ function createQueryHandle(rawQuery, messageQueue, abortController) {
           return rawIter.next().then(function(result) {
             if (result.done) { closed = true; removeAbort(); resolveStopped(); }
             if (result.done) return result;
+            taskReader.observe(result.value);
             return { value: correlation.result(result.value, flattenEvent(result.value)), done: false };
           }, function(err) {
             closed = true;
@@ -676,6 +681,8 @@ function createQueryHandle(rawQuery, messageQueue, abortController) {
       return Promise.resolve();
     },
 
+    readBackgroundTask: taskReader.read,
+
     stopTask: function(taskId) {
       if (rawQuery && typeof rawQuery.stopTask === "function") {
         return rawQuery.stopTask(taskId);
@@ -1107,6 +1114,7 @@ function serializeWorkerValue(value, seen) {
 function createWorkerQueryHandle(worker, canUseTool, onElicitation, callMcpTool, onUserDialog, onUserInputRequest, onModelSwitch, preToolUsePolicy) {
   var interactionAbort = new AbortController();
   var contextRequests = claudeContextUsage.createRequests(worker);
+  var taskRequests = taskReaderModule.createRequests(worker);
   var correlation = claudeCorrelation.createCorrelation();
   // Async iterable state
   var iterQueue = [];
@@ -1153,6 +1161,7 @@ function createWorkerQueryHandle(worker, canUseTool, onElicitation, callMcpTool,
   function endIter() {
     interactionAbort.abort();
     contextRequests.close();
+    taskRequests.close();
     if (iterEnded) return;
     iterEnded = true;
     if (iterWaiting) {
@@ -1165,6 +1174,7 @@ function createWorkerQueryHandle(worker, canUseTool, onElicitation, callMcpTool,
   function errorIter(err) {
     interactionAbort.abort();
     contextRequests.close();
+    taskRequests.close();
     if (iterEnded) return;
     iterEnded = true;
     iterError = err;
@@ -1292,6 +1302,9 @@ function createWorkerQueryHandle(worker, canUseTool, onElicitation, callMcpTool,
       case "model_switched":
         if (onModelSwitch) onModelSwitch(msg.change);
         break;
+      case "background_task_response":
+        taskRequests.receive(msg);
+        break;
       case "context_usage_response":
         contextRequests.receive(msg);
         break;
@@ -1458,6 +1471,8 @@ function createWorkerQueryHandle(worker, canUseTool, onElicitation, callMcpTool,
       });
     },
 
+    readBackgroundTask: function(input) { return iterEnded ? Promise.reject(new Error("Task connection closed.")) : taskRequests.request(input); },
+
     stopTask: function(taskId) {
       worker.send({ type: "stop_task", taskId: taskId });
       return Promise.resolve();
@@ -1821,7 +1836,7 @@ function createClaudeAdapter(opts) {
 
       claudeModelSwitch.attach(sdkOptions, queryOpts.onModelSwitch);
       var rawQuery = sdk.query({ prompt: mq, options: sdkOptions });
-      return createQueryHandle(rawQuery, mq, ac);
+      return createQueryHandle(rawQuery, mq, ac, sdkOptions.cwd || _cwd);
     },
 
     createOneShotQuery: async function(queryOpts) {