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

package/lib/project-view-store.js

@@ -0,0 +1,346 @@
+var fs = require("fs");
+var path = require("path");
+var crypto = require("crypto");
+var layout = require("./split-view-layout");
+var workspace = require("./project-view-workspace");
+var checkInput = require("./project-view-input").check;
+var names = require("./project-split-view-names");
+var validDocument = require("./project-split-view-document").validDocument;
+function clone(value) { return JSON.parse(JSON.stringify(value)); }
+function ownerKey(ownerId) { return ownerId == null ? "default" : "user:" + String(ownerId); }
+function emptyDocument() { return { version: 1, projects: {} }; }
+function emptyOwner(ownerId, linuxUser) { return { ownerId: ownerId == null ? null : String(ownerId), linuxUser: linuxUser || null, revision: 0, views: [] }; }
+function createSplitViewsStore(opts) {
+  var slug = opts.slug;
+  var sessionsDir = opts.sessionsDir;
+  var filePath = opts.filePath || path.join(sessionsDir, "presentation-split-views.json");
+  var fsImpl = opts.fs || fs;
+  var persist = opts.persist || null;
+  var document = emptyDocument();
+  var loadError = null;
+  try {
+    var loaded = JSON.parse(fsImpl.readFileSync(filePath, "utf8"));
+    if (!validDocument(loaded)) throw new Error("Stored Split view data is invalid");
+    document = loaded;
+  } catch (error) {
+    if (!error || error.code !== "ENOENT") loadError = error;
+  }
+  function projectRecord(source, create) {
+    if (!source.projects[slug] && create) source.projects[slug] = { owners: {} };
+    return source.projects[slug] || null;
+  }
+  function ownerRecord(source, ownerId, linuxUser, create) {
+    var project = projectRecord(source, create);
+    if (!project) return null;
+    var key = ownerKey(ownerId), record = project.owners[key];
+    if (!record && create) { record = emptyOwner(ownerId, linuxUser); project.owners[key] = record; }
+    if (record && (record.ownerId !== (ownerId == null ? null : String(ownerId)) || record.linuxUser !== (linuxUser || null))) return { identityMismatch: true };
+    return record || null;
+  }
+  function save(next) {
+    if (!validDocument(next)) throw new Error("Split view state failed validation");
+    var serialized = JSON.stringify(next, null, 2) + "\n";
+    if (persist) {
+      if (persist(filePath, serialized) === false) throw new Error("Split view persistence returned false");
+      return;
+    }
+    fsImpl.mkdirSync(sessionsDir, { recursive: true });
+    var tempPath = filePath + ".tmp." + process.pid + "." + crypto.randomBytes(4).toString("hex");
+    try {
+      fsImpl.writeFileSync(tempPath, serialized, { encoding: "utf8", flag: "wx", mode: 0o600 });
+      if (process.platform !== "win32") try { fsImpl.chmodSync(tempPath, 0o600); } catch (e) {}
+      fsImpl.renameSync(tempPath, filePath);
+    } catch (error) {
+      try { fsImpl.unlinkSync(tempPath); } catch (e) {}
+      throw error;
+    }
+  }
+  function state(ownerId, linuxUser) {
+    if (loadError) return { ok: false, error: "Stored Split view data could not be read; no changes were made", code: "storage", revision: 0, views: [] };
+    var record = ownerRecord(document, ownerId, linuxUser, false);
+    if (record && record.identityMismatch) return { ok: false, error: "Split view owner or OS identity changed", code: "identity", revision: 0, views: [] };
+    return record ? { ok: true, revision: record.revision, activeViewId: record.activeViewId || null, views: record.views.map(workspace.normalized) } : { ok: true, revision: 0, views: [] };
+  }
+  function conflict(actual) { return { ok: false, error: "Split view state changed. Reload and try again.", code: "conflict", revision: actual }; }
+  function validateRevision(value) { return Number.isSafeInteger(value) && value >= 0; }
+  function prepareRecord(ownerId, linuxUser, expectedRevision) {
+    var current = state(ownerId, linuxUser);
+    if (!current.ok) return current;
+    if (!validateRevision(expectedRevision) || expectedRevision !== current.revision) return conflict(current.revision);
+    var next = clone(document), record = ownerRecord(next, ownerId, linuxUser, true);
+    return { ok: true, next: next, record: record };
+  }
+  function commit(ownerId, record, changedView) {
+    record.revision++;
+    if (Array.isArray(changedView)) changedView.forEach(function (view) { if (view) view.revision = record.revision; });
+    else if (changedView) changedView.revision = record.revision;
+    try { save(documentForOwner(record, ownerId)); }
+    catch (error) { return { ok: false, error: error.message || String(error), code: "storage", revision: state(ownerId, record.linuxUser).revision }; }
+    document = documentForOwner(record, ownerId);
+    var resultView = Array.isArray(changedView) ? changedView[changedView.length - 1] : changedView;
+    return { ok: true, revision: record.revision, view: resultView ? workspace.normalized(resultView) : null, views: record.views.map(workspace.normalized) };
+  }
+  function documentForOwner(record, ownerId) {
+    var next = clone(document), project = projectRecord(next, true);
+    project.owners[ownerKey(ownerId)] = clone(record);
+    return next;
+  }
+  function validExpectedView(record, id) {
+    if (typeof id !== "string" || !id) return { error: "Split view not found" };
+    var index = record.views.findIndex(function (view) { return view.id === id; });
+    if (index === -1) return { error: "Split view not found" };
+    return { index: index, view: record.views[index] };
+  }
+  function refsFor(origins, resolvedRefs) {
+    if (!Array.isArray(origins) || origins.length > layout.MAX_SESSIONS ||
+        origins.some(function (origin) { return !layout.validOrigin(origin); }) || new Set(origins).size !== origins.length) return { error: "A View supports zero to eight unique session origins" };
+    if (!Array.isArray(resolvedRefs) || resolvedRefs.length !== origins.length) return { error: "One or more exact sessions could not be resolved" };
+    var refs = [];
+    for (var i = 0; i < origins.length; i++) {
+      var ref = resolvedRefs.find(function (item) { return item && item.originId === origins[i]; });
+      if (!ref) return { error: "One or more exact sessions could not be resolved" };
+      refs.push({ originId: ref.originId, ownerId: ref.ownerId == null ? null : String(ref.ownerId), linuxUser: ref.linuxUser || null });
+    }
+    return { refs: refs };
+  }
+  function validateComposition(input, refs) {
+    var origins = refs.map(function (ref) { return ref.originId; }), tree = layout.validateTree(input.tree, origins), preset = input.layout;
+    if (!tree.ok) return { error: tree.error };
+    if (!layout.validatePreset(preset)) return { error: "Unknown Split view layout" };
+    if (origins.length ? typeof input.activeSessionOriginId !== "string" || origins.indexOf(input.activeSessionOriginId) === -1 : input.activeSessionOriginId !== null) return { error: "Active session must belong to the Split view" };
+    if (input.workspace !== undefined) {
+      var checked = workspace.validate(input.workspace, { tree: input.tree, sessionRefs: refs });
+      if (!checked.ok) return { error: checked.error };
+    }
+    return { origins: origins };
+  }
+  function uniqueMembership(views, refs, exceptId, secondExceptId) {
+    var used = [];
+    views.forEach(function (view) {
+      if (view.id === exceptId || view.id === secondExceptId) return;
+      view.sessionRefs.forEach(function (ref) { used.push(ref.originId); });
+    });
+    return refs.every(function (ref) { return used.indexOf(ref.originId) === -1; });
+  }
+  function create(ownerId, linuxUser, input, resolvedRefs) {
+    input = input || {};
+    var prepared = prepareRecord(ownerId, linuxUser, input.expectedRevision);
+    if (!prepared.ok) return prepared;
+    var identity = checkInput(input, slug, ownerId, input.workspace !== undefined || Array.isArray(input.sessionOrigins) && input.sessionOrigins.length < 2);
+    if (!identity.ok) return identity;
+    var name = layout.validateName(input.name), refs = refsFor(input.sessionOrigins, resolvedRefs);
+    if (!name.ok) return name;
+    if (refs.error) return { ok: false, error: refs.error };
+    var composition = validateComposition(input, refs.refs);
+    if (composition.error) return { ok: false, error: composition.error };
+    if (!uniqueMembership(prepared.record.views, refs.refs)) return { ok: false, error: "A session can belong to only one Split view" };
+    var nameMode = input.nameMode === "custom" ? "custom" : "automatic";
+    var view = { id: crypto.randomUUID(), name: nameMode === "automatic" ? names.automaticName(input.liveSessions) : name.name, nameMode: nameMode,
+      folderId: null, favorite: false, revision: prepared.record.revision + 1, layout: input.layout,
+      activeSessionOriginId: input.activeSessionOriginId, tree: clone(input.tree), sessionRefs: refs.refs };
+    if (input.workspace !== undefined || refs.refs.length < 2) view.workspace = input.workspace === undefined ? workspace.legacy(view) : clone(input.workspace);
+    prepared.record.views.push(view);
+    if (input.active === true) prepared.record.activeViewId = view.id;
+    return commit(ownerId, prepared.record, view);
+  }
+  function update(ownerId, linuxUser, input, resolvedRefs) {
+    input = input || {};
+    var prepared = prepareRecord(ownerId, linuxUser, input.expectedRevision);
+    if (!prepared.ok) return prepared;
+    var found = validExpectedView(prepared.record, input.id, input.expectedRevision);
+    if (found.error) return { ok: false, error: found.error };
+    if (found.conflict) return conflict(found.revision);
+    var identity = checkInput(input, slug, ownerId, found.view.workspace !== undefined || input.workspace !== undefined || Array.isArray(input.sessionOrigins) && input.sessionOrigins.length < 2, found.view);
+    if (!identity.ok) return identity;
+    var refs = refsFor(input.sessionOrigins, resolvedRefs);
+    if (refs.error) return { ok: false, error: refs.error };
+    if (found.view.workspace && input.workspace === undefined) return { ok: false, code: "workspace_required", error: "Update the complete workspace to preserve pane identities and layout" };
+    var ordered = names.update(found.view, refs.refs, input.liveSessions);
+    if (!ordered) return { ok: false, error: "One or more exact sessions could not be resolved" };
+    refs.refs = ordered.refs; input.liveSessions = ordered.sessions;
+    var composition = validateComposition(input, refs.refs);
+    if (composition.error) return { ok: false, error: composition.error };
+    if (input.workspace !== undefined) {
+      var transitioned = workspace.transition(workspace.normalized(found.view).workspace, input.workspace);
+      if (!transitioned.ok) return transitioned;
+    }
+    if (!uniqueMembership(prepared.record.views, refs.refs, input.id)) return { ok: false, error: "A session can belong to only one Split view" };
+    if (names.mode(found.view) === "automatic") found.view.name = names.automaticName(input.liveSessions);
+    found.view.layout = input.layout; found.view.activeSessionOriginId = input.activeSessionOriginId;
+    found.view.tree = clone(input.tree); found.view.sessionRefs = refs.refs;
+    if (input.workspace !== undefined || refs.refs.length < 2) found.view.workspace = input.workspace === undefined ? workspace.legacy(found.view) : clone(input.workspace);
+    if (input.active === true) prepared.record.activeViewId = found.view.id;
+    return commit(ownerId, prepared.record, found.view);
+  }
+  function rename(ownerId, linuxUser, input) {
+    input = input || {};
+    var prepared = prepareRecord(ownerId, linuxUser, input.expectedRevision);
+    if (!prepared.ok) return prepared;
+    var found = validExpectedView(prepared.record, input.id, input.expectedRevision);
+    if (found.error) return { ok: false, error: found.error };
+    if (found.conflict) return conflict(found.revision);
+    var identity = checkInput(input, slug, ownerId, found.view.workspace !== undefined || input.workspace !== undefined || Array.isArray(input.sessionOrigins) && input.sessionOrigins.length < 2, found.view);
+    if (!identity.ok) return identity;
+    var name = layout.validateName(input.name);
+    if (!name.ok) return name;
+    found.view.name = name.name;
+    found.view.nameMode = "custom";
+    if (input.active === true) prepared.record.activeViewId = found.view.id;
+    return commit(ownerId, prepared.record, found.view);
+  }
+  function separate(ownerId, linuxUser, input) {
+    input = input || {};
+    var prepared = prepareRecord(ownerId, linuxUser, input.expectedRevision);
+    if (!prepared.ok) return prepared;
+    var found = validExpectedView(prepared.record, input.id, input.expectedRevision);
+    if (found.error) return { ok: false, error: found.error };
+    if (found.conflict) return conflict(found.revision);
+    var identity = checkInput(input, slug, ownerId, found.view.workspace !== undefined || input.workspace !== undefined || Array.isArray(input.sessionOrigins) && input.sessionOrigins.length < 2, found.view);
+    if (!identity.ok) return identity;
+    var removed = prepared.record.views.splice(found.index, 1)[0];
+    if (prepared.record.activeViewId === removed.id) prepared.record.activeViewId = null;
+    return commit(ownerId, prepared.record, null);
+  }
+  function move(ownerId, linuxUser, input, resolvedSourceRefs, resolvedTargetRefs) {
+    input = input || {};
+    var prepared = prepareRecord(ownerId, linuxUser, input.expectedRevision);
+    if (!prepared.ok) return prepared;
+    if (typeof input.sourceSessionOriginId !== "string" || !layout.validOrigin(input.sourceSessionOriginId)) return { ok: false, error: "A valid source session is required", code: "invalid" };
+    var source = validExpectedView(prepared.record, input.sourceViewId);
+    if (source.error) return { ok: false, error: "Source Split view not found", code: "not_found", revision: prepared.record.revision };
+    if ((source.view.workspace || input.workspace !== undefined) && input.targetWorkspace === undefined) return { ok: false, code: "workspace_required", error: "Legacy move does not support workspace Views" };
+    var identity = checkInput(input, slug, ownerId, !!input.targetWorkspace, source.view);
+    if (!identity.ok) return identity;
+    var sourceOrigins = source.view.sessionRefs.map(function (ref) { return ref.originId; });
+    if (sourceOrigins.indexOf(input.sourceSessionOriginId) === -1) return { ok: false, error: "Source session does not belong to the source Split view", code: "session", revision: prepared.record.revision };
+    if (!Array.isArray(resolvedSourceRefs) || resolvedSourceRefs.length !== source.view.sessionRefs.length) return { ok: false, error: "Source sessions could not be resolved", code: "session", revision: prepared.record.revision };
+    for (var i = 0; i < source.view.sessionRefs.length; i++) {
+      var storedSource = source.view.sessionRefs[i], liveSource = resolvedSourceRefs.find(function (ref) { return ref && ref.originId === storedSource.originId; });
+      if (!liveSource || (liveSource.ownerId || null) !== (storedSource.ownerId || null) || (liveSource.linuxUser || null) !== (storedSource.linuxUser || null)) {
+        return { ok: false, error: "A source session was replaced or changed identity", code: "session", revision: prepared.record.revision };
+      }
+    }
+    var target = null, targetSessionOriginId = input.targetSessionOriginId;
+    var hasTargetView = typeof input.targetViewId === "string" && input.targetViewId.length > 0;
+    var hasStandaloneTarget = typeof targetSessionOriginId === "string" && layout.validOrigin(targetSessionOriginId);
+    if (hasTargetView === hasStandaloneTarget || (input.targetViewId != null && !hasTargetView)) {
+      return { ok: false, error: "Choose exactly one target Split view or standalone session", code: "invalid", revision: prepared.record.revision };
+    }
+    if (hasTargetView) {
+      target = validExpectedView(prepared.record, input.targetViewId);
+      if (target.error || target.view.id === source.view.id) return { ok: false, error: "Target Split view is unavailable", code: "not_found", revision: prepared.record.revision };
+    }
+    if (target && target.view.workspace && input.targetWorkspace === undefined) return { ok: false, code: "workspace_required", error: "Legacy move does not support workspace Views" };
+    if (Array.isArray(input.targetSessionOrigins) && input.targetSessionOrigins.length > layout.MAX_SESSIONS) {
+      return { ok: false, error: "A Split view can contain at most eight sessions", code: "limit", revision: prepared.record.revision };
+    }
+    var targetRefs = refsFor(input.targetSessionOrigins, resolvedTargetRefs);
+    if (targetRefs.error) return { ok: false, error: targetRefs.error, code: "session", revision: prepared.record.revision };
+    var requestedTargetOrigins = targetRefs.refs.map(function (ref) { return ref.originId; });
+    if (requestedTargetOrigins.indexOf(input.sourceSessionOriginId) === -1) return { ok: false, error: "Target layout must include the moved source session", code: "invalid", revision: prepared.record.revision };
+    if (target) {
+      var requestedPriorOrigins = target.view.sessionRefs.map(function (ref) { return ref.originId; });
+      if (requestedTargetOrigins.length !== requestedPriorOrigins.length + 1 || requestedPriorOrigins.some(function (origin) { return requestedTargetOrigins.indexOf(origin) === -1; })) {
+        return { ok: false, error: "Target layout must preserve every existing target session", code: "invalid", revision: prepared.record.revision };
+      }
+      if (!uniqueMembership(prepared.record.views, targetRefs.refs, target.view.id, source.view.id)) return { ok: false, error: "A target session belongs to another Split view", code: "membership", revision: prepared.record.revision };
+    } else if (targetSessionOriginId === input.sourceSessionOriginId || requestedTargetOrigins.length !== 2 || requestedTargetOrigins.indexOf(targetSessionOriginId) === -1) {
+      return { ok: false, error: "A standalone target transfer requires exactly the target and moved sessions", code: "invalid", revision: prepared.record.revision };
+    } else if (!uniqueMembership(prepared.record.views, targetRefs.refs, source.view.id)) {
+      return { ok: false, error: "A standalone target session already belongs to a Split view", code: "membership", revision: prepared.record.revision };
+    }
+    if (target) { var orderedTarget = names.append(target.view, targetRefs.refs, input.liveSessions, input.sourceSessionOriginId);
+      if (!orderedTarget) return { ok: false, error: "Target layout must preserve existing sessions and include the moved source exactly once", code: "invalid", revision: prepared.record.revision };
+      targetRefs.refs = orderedTarget.refs; input.liveSessions = orderedTarget.sessions; }
+    else { var orderedStandalone = names.targetFirst(targetRefs.refs, input.liveSessions, targetSessionOriginId, input.sourceSessionOriginId);
+      if (!orderedStandalone) return { ok: false, error: "A standalone target transfer requires exactly the target and moved sessions", code: "invalid", revision: prepared.record.revision };
+      targetRefs.refs = orderedStandalone.refs; input.liveSessions = orderedStandalone.sessions; }
+    var targetOrigins = targetRefs.refs.map(function (ref) { return ref.originId; });
+    if (!layout.validatePreset(input.layout) || !layout.validateTree(input.tree, targetOrigins).ok || targetOrigins.length > layout.MAX_SESSIONS) {
+      return { ok: false, error: "Target layout is invalid or exceeds the eight-session limit", code: targetOrigins.length > layout.MAX_SESSIONS ? "limit" : "invalid", revision: prepared.record.revision };
+    }
+    if (typeof input.activeSessionOriginId !== "string" || targetOrigins.indexOf(input.activeSessionOriginId) === -1) {
+      return { ok: false, error: "Active session must belong to the target Split view", code: "invalid", revision: prepared.record.revision };
+    }
+    if (!target) {
+      var name = layout.validateName(input.name);
+      if (!name.ok) return { ok: false, error: name.error, code: "invalid", revision: prepared.record.revision };
+    }
+    if (input.targetWorkspace !== undefined) {
+      if (target && input.expectedTargetViewRevision !== target.view.revision) return conflict(prepared.record.revision);
+      var checked = workspace.validate(input.targetWorkspace, { tree: input.tree, sessionRefs: targetRefs.refs });
+      if (!checked.ok) return checked;
+      var prior = target ? workspace.normalized(target.view).workspace : { panes: [] };
+      if (prior.panes.some(function (pane) { return !input.targetWorkspace.panes.some(function (next) { return workspace.samePane(next, pane); }); })) return { ok: false, code: 'workspace', error: 'Move must preserve every existing target pane and binding' };
+      var transitioned = workspace.transition(prior, input.targetWorkspace);
+      if (!transitioned.ok) return transitioned;
+      var movedPane = workspace.normalized(source.view).workspace.panes.find(function (pane) { return pane.kind === 'session' && pane.resource.originId === input.sourceSessionOriginId; });
+      var destination = input.targetWorkspace.panes.find(function (pane) { return pane.kind === 'session' && pane.resource.originId === input.sourceSessionOriginId; });
+      if (!movedPane || !destination || movedPane.instanceId !== destination.instanceId) return { ok: false, code: 'identity', error: 'Move must retain the exact pane instance' };
+    }
+    var nextSourceOrigins = sourceOrigins.filter(function (origin) { return origin !== input.sourceSessionOriginId; });
+    source.view.tree = layout.removeLeaf(source.view.tree, input.sourceSessionOriginId);
+    source.view.sessionRefs = source.view.sessionRefs.filter(function (ref) { return ref.originId !== input.sourceSessionOriginId; });
+    if (source.view.activeSessionOriginId === input.sourceSessionOriginId) source.view.activeSessionOriginId = nextSourceOrigins[0] || null;
+    workspace.removeSession(source.view, input.sourceSessionOriginId);
+    if (nextSourceOrigins.length < 2 && !source.view.workspace) { prepared.record.views.splice(source.index, 1); if (prepared.record.activeViewId === source.view.id) prepared.record.activeViewId = null; }
+    if (nextSourceOrigins.length >= 2 && names.mode(source.view) === "automatic") source.view.name = names.automaticName(input.sourceLiveSessions.filter(function (session) { return session.sessionOriginId !== input.sourceSessionOriginId; }));
+    if (target) {
+      target.view.tree = clone(input.tree); target.view.layout = input.layout;
+      target.view.activeSessionOriginId = input.activeSessionOriginId; target.view.sessionRefs = targetRefs.refs;
+      if (names.mode(target.view) === "automatic") target.view.name = names.automaticName(input.liveSessions);
+    } else {
+      target = { index: -1, view: { id: crypto.randomUUID(), folderId: null, favorite: false, name: names.automaticName(input.liveSessions), nameMode: "automatic", revision: prepared.record.revision + 1,
+        layout: input.layout, activeSessionOriginId: input.activeSessionOriginId, tree: clone(input.tree), sessionRefs: targetRefs.refs } };
+      prepared.record.views.push(target.view);
+    }
+    if (input.targetWorkspace !== undefined) target.view.workspace = clone(input.targetWorkspace);
+    if (input.active === true) prepared.record.activeViewId = target.view.id;
+    var changed = [target.view];
+    if (nextSourceOrigins.length >= 2 || source.view.workspace) changed.unshift(source.view);
+    return commit(ownerId, prepared.record, changed);
+  }
+  function removeOrigin(originId) {
+    var project = projectRecord(document, false), changedOwners = [], failures = [];
+    if (!project) return { owners: changedOwners, failures: failures };
+    var keys = Object.keys(project.owners);
+    for (var i = 0; i < keys.length; i++) {
+      var source = project.owners[keys[i]], next = clone(source), changed = false, retained = [];
+      for (var j = 0; j < next.views.length; j++) {
+        var view = next.views[j], member = view.sessionRefs.some(function (ref) { return ref.originId === originId; });
+        if (!member) { retained.push(view); continue; }
+        changed = true;
+        var tree = layout.removeLeaf(view.tree, originId), origins = view.sessionRefs.filter(function (ref) { return ref.originId !== originId; });
+        if (origins.length < 2 && !view.workspace) continue;
+        view.tree = tree;
+        view.sessionRefs = origins;
+        if (view.activeSessionOriginId === originId) view.activeSessionOriginId = origins.length ? origins[0].originId : null;
+        workspace.removeSession(view, originId);
+        retained.push(view);
+      }
+      if (!changed) continue;
+      next.views = retained;
+      if (next.activeViewId && !retained.some(function (view) { return view.id === next.activeViewId; })) next.activeViewId = null;
+      next.revision++;
+      next.views.forEach(function (view) { view.revision = next.revision; });
+      try {
+        var replacement = documentForOwner(next, source.ownerId);
+        save(replacement);
+        document = replacement;
+        changedOwners.push(source.ownerId);
+      } catch (error) { failures.push({ ownerId: source.ownerId, error: error.message || String(error) }); }
+    }
+    return { owners: changedOwners, failures: failures };
+  }
+  var organization = require('./project-split-view-organization').attachOrganization({ prepare: prepareRecord, commit: commit, state: state });
+  function organize(ownerId, linuxUser, input) {
+    var prepared = prepareRecord(ownerId, linuxUser, input.expectedRevision);
+    if (!prepared.ok) return prepared;
+    var view = prepared.record.views.find(function (item) { return item.id === input.id; });
+    var checked = checkInput(input, slug, ownerId, !!(view && view.workspace), view);
+    return checked.ok ? organization.organize(ownerId, linuxUser, input) : checked;
+  }
+  return { organize: organize, reconcileFolders: organization.reconcileFolders, state: state, create: create, update: update, rename: rename, separate: separate, move: move, removeOrigin: removeOrigin,
+    get filePath() { return filePath; }, get loadError() { return loadError; } };
+}
+module.exports = { createSplitViewsStore: createSplitViewsStore };

package/lib/project-view-terminal-binding.js

@@ -0,0 +1,16 @@
+// Saved descriptors are UI state, never authority to attach a terminal.
+function attachSaved(ctx, ws, message) {
+  var binding = message.savedBinding;
+  if (!binding) return false;
+  var terminal = ctx.tm.inspect(message.id), user = ws._clayUser;
+  var osUser = ctx.getOsUserInfoForWs ? ctx.getOsUserInfoForWs(ws) : null;
+  var osIdentity = osUser ? JSON.stringify([osUser.user, osUser.uid, osUser.gid, osUser.home]) : null;
+  var allowed = terminal && !terminal.exited && terminal.kind !== 'tui-session' &&
+    binding.identity === terminal.identity && binding.runtimeId === require('./clay-control-target-projection').runtime(ctx.sm) &&
+    terminal.ownerId === (user ? user.id : null) && (terminal.osIdentity || null) === osIdentity;
+  if (user && !ctx.usersModule.getEffectivePermissions(user, ctx.osUsers).terminal) allowed = false;
+  if (!allowed) { ctx.sendTo(ws, { type: 'term_error', id: message.id, error: 'The exact saved terminal is unavailable or access changed.' }); return true; }
+  ctx.tm.attach(message.id, ws);
+  return true;
+}
+module.exports = { attachSaved: attachSaved };

package/lib/project-view-workspace.js

@@ -0,0 +1,126 @@
+var WORKBENCH_NAMES = ['project-logs', 'you', 'issues', 'linear', 'notes-browser', 'scheduled-tasks', 'debates', 'mcp-skills', 'mate-knowledge', 'wireframe'];
+// Persisted UI descriptors confer no authority. Restore must resolve every
+// resource through its live authenticated service; this module performs no I/O.
+var crypto = require('crypto');
+var MAX_TOOLS = 16;
+var MAX_PANES = 24;
+function copy(value) { return JSON.parse(JSON.stringify(value)); }
+function object(value) { return !!value && typeof value === 'object' && !Array.isArray(value); }
+function keys(value, fields) { return object(value) && Object.keys(value).sort().join(',') === fields.split(',').sort().join(','); }
+function id(value) { return typeof value === 'string' && /^[A-Za-z0-9_-]{1,128}$/.test(value); }
+function runtimeId(value) { return id(value) || typeof value === 'string' && /^runtime:[A-Za-z0-9_-]{1,128}$/.test(value); }
+function filePath(value) {
+  return typeof value === 'string' && value.length > 0 && value.length <= 4096 &&
+    !/[\\\x00-\x1f\x7f:]/.test(value) && value.split('/').every(function (part) { return part && part !== '.' && part !== '..'; });
+}
+function sessionId(origin) { return 'session-' + crypto.createHash('sha256').update(origin).digest('hex').slice(0, 32); }
+function mapTree(tree, map) {
+  if (!tree) return null;
+  if (tree.id) return map[tree.id] ? { id: map[tree.id] } : null;
+  var left = mapTree(tree.left, map), right = mapTree(tree.right, map);
+  return !left ? right : !right ? left : { axis: tree.axis, ratio: tree.ratio, left: left, right: right };
+}
+function legacy(view) {
+  var mapping = Object.create(null), panes = view.sessionRefs.map(function (ref) {
+    var instanceId = sessionId(ref.originId); mapping[ref.originId] = instanceId;
+    return { instanceId: instanceId, kind: 'session', open: true, placement: 'docked', resource: { originId: ref.originId } };
+  });
+  return { version: 1, panes: panes, tree: mapTree(view.tree, mapping), activePaneId: mapping[view.activeSessionOriginId] || null };
+}
+function normalized(view) {
+  var result = copy(view);
+  if (result.workspace === undefined) result.workspace = legacy(view);
+  return result;
+}
+function validTree(tree, expected) {
+  var seen = [], nodes = 0;
+  function walk(node, depth) {
+    if (!object(node) || ++nodes > MAX_PANES * 2 - 1 || depth > MAX_PANES) return false;
+    if (keys(node, 'id')) {
+      if (!id(node.id) || seen.indexOf(node.id) >= 0) return false;
+      seen.push(node.id); return true;
+    }
+    return keys(node, 'axis,ratio,left,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);
+  }
+  if (!expected.length) return tree === null;
+  return walk(tree, 0) && seen.length === expected.length && expected.every(function (value) { return seen.indexOf(value) >= 0; });
+}
+function sameTree(a, b) {
+  if (!a || !b) return a === b;
+  if (a.id || b.id) return a.id === b.id;
+  return a.axis === b.axis && a.ratio === b.ratio && sameTree(a.left, b.left) && sameTree(a.right, b.right);
+}
+function failure(message) { return { ok: false, code: 'workspace', error: message }; }
+function validate(value, view) {
+  if (!object(value)) return failure('Invalid View workspace');
+  if (!keys(value, 'version,panes,tree,activePaneId' + (value.linkedPair === undefined ? '' : ',linkedPair') + (value.presentation === undefined ? '' : ',presentation')) || value.version !== 1 || !Array.isArray(value.panes) || value.panes.length > MAX_PANES) return failure('Invalid View workspace');
+  var instances = [], sessions = [], resources = [], docked = [], open = [], tools = 0, files = 0, overlays = 0, mapping = Object.create(null);
+  for (var i = 0; i < value.panes.length; i++) {
+    var pane = value.panes[i];
+    if (!keys(pane, 'instanceId,kind,open,placement,resource') || !id(pane.instanceId) || instances.indexOf(pane.instanceId) >= 0 ||
+        typeof pane.open !== 'boolean' || ['docked', 'overlay'].indexOf(pane.placement) < 0) return failure('Invalid or duplicate pane instance');
+    instances.push(pane.instanceId);
+    var resource = pane.resource;
+    if (pane.kind === 'session') {
+      if (!keys(resource, 'originId') || !id(resource.originId) || sessions.indexOf(resource.originId) >= 0 || !pane.open || pane.placement !== 'docked') return failure('Invalid session pane');
+      sessions.push(resource.originId); mapping[pane.instanceId] = resource.originId;
+    } else {
+      if (++tools > MAX_TOOLS) return failure('A View supports at most sixteen tool panes');
+      if (pane.kind === 'terminal' || pane.kind === 'browser') {
+        var terminal = pane.kind === 'terminal';
+        if (terminal ? !keys(resource, 'id,runtimeId,identity') || !Number.isSafeInteger(resource.id) || resource.id < 1 || !id(resource.identity) || !runtimeId(resource.runtimeId) :
+            !keys(resource, 'id,runtimeId,sessionOriginId') || !id(resource.id) || !runtimeId(resource.runtimeId) || !id(resource.sessionOriginId)) return failure('Invalid runtime resource descriptor');
+        var identity = pane.kind + ':' + resource.runtimeId + ':' + resource.id;
+        if (resources.indexOf(identity) >= 0) return failure('Duplicate runtime resource');
+        resources.push(identity);
+      } else if (pane.kind === 'file') {
+        if (++files > 8) return failure('A View supports at most eight file panes');
+        if (!keys(resource, 'path,mode,rendered') || !filePath(resource.path) || ['follow', 'pin'].indexOf(resource.mode) < 0 || typeof resource.rendered !== 'boolean') return failure('Invalid file resource descriptor');
+      } else if (pane.kind === 'workbench') {
+        if (!keys(resource, 'name') || WORKBENCH_NAMES.indexOf(resource.name) < 0 || resources.indexOf('workbench:' + resource.name) >= 0) return failure('Invalid or duplicate workbench');
+        resources.push('workbench:' + resource.name);
+      } else return failure('Unknown pane kind');
+    }
+    if (pane.open) { open.push(pane.instanceId); if (pane.placement === 'docked') docked.push(pane.instanceId); else overlays++; }
+  }
+  var origins = view.sessionRefs.map(function (ref) { return ref.originId; });
+  if (sessions.length !== origins.length || origins.some(function (origin) { return sessions.indexOf(origin) < 0; })) return failure('Workspace sessions must exactly match View membership');
+  if (overlays > 1 || !validTree(value.tree, docked)) return failure('Workspace layout must exactly match open docked panes');
+  if (open.length ? open.indexOf(value.activePaneId) < 0 : value.activePaneId !== null) return failure('Active pane must be open');
+  if (!sameTree(mapTree(value.tree, mapping), view.tree)) return failure('Session tree must match the workspace session projection');
+  if (value.presentation !== undefined && (!keys(value.presentation, 'focusedSessionOriginId,expandedPaneId') || value.presentation.focusedSessionOriginId !== null && sessions.indexOf(value.presentation.focusedSessionOriginId) < 0 || value.presentation.expandedPaneId !== null && !value.panes.some(function (p) { return p.kind !== 'session' && p.open && p.instanceId === value.presentation.expandedPaneId; }))) return failure('Invalid View presentation');
+  if (value.linkedPair !== undefined && !require('./project-view-pair').valid(value.linkedPair, value, view)) return failure('Invalid linked Worker presentation');
+  return { ok: true };
+}
+function samePane(a, b) {
+  return a.instanceId === b.instanceId && a.kind === b.kind && a.open === b.open && a.placement === b.placement &&
+    Object.keys(a.resource).length === Object.keys(b.resource).length && Object.keys(a.resource).every(function (key) { return a.resource[key] === b.resource[key]; });
+}
+function transition(previous, next) {
+  for (var i = 0; i < next.panes.length; i++) {
+    var pane = next.panes[i], prior = previous.panes.find(function (item) { return item.instanceId === pane.instanceId; });
+    if (!prior) continue;
+    if (pane.kind !== prior.kind || pane.kind !== 'file' && Object.keys(pane.resource).some(function (key) { return pane.resource[key] !== prior.resource[key]; })) return failure('An existing pane instance cannot change resource identity');
+  }
+  return { ok: true };
+}
+// Session deletion never discards another pane or its binding. The legacy
+// session tree is a compatibility projection of the authoritative workspace.
+function removeSession(view, origin) {
+  if (!view.workspace) return;
+  if (view.workspace.linkedPair && view.workspace.linkedPair.driverOriginId === origin) delete view.workspace.linkedPair;
+  var value = view.workspace, mapping = Object.create(null), sessionMapping = Object.create(null);
+  value.panes = value.panes.filter(function (pane) { return pane.kind !== 'session' || pane.resource.originId !== origin; });
+  value.panes.forEach(function (pane) { mapping[pane.instanceId] = pane.instanceId; if (pane.kind === 'session') sessionMapping[pane.instanceId] = pane.resource.originId; });
+  value.tree = mapTree(value.tree, mapping);
+  view.tree = mapTree(value.tree, sessionMapping);
+  if (value.presentation && value.presentation.focusedSessionOriginId === origin) value.presentation.focusedSessionOriginId = null;
+  if (!value.panes.some(function (pane) { return pane.open && pane.instanceId === value.activePaneId; })) {
+    var active = value.panes.find(function (pane) { return pane.open; }); value.activePaneId = active ? active.instanceId : null;
+  }
+}
+module.exports = { samePane: samePane, MAX_TOOLS: MAX_TOOLS, MAX_PANES: MAX_PANES, validate: validate, transition: transition,
+  normalized: normalized, legacy: legacy, removeSession: removeSession, validFilePath: filePath };
+
+module.exports.workbenchNames = WORKBENCH_NAMES;

package/lib/project.js

@@ -699,6 +699,7 @@ function createProjectContext(opts) {
     },
   });
   var _splitViews = attachProjectSplitViews({
+    getViewPairGroup: function (id) { return _splitGroups.store.groupForMember(id); },
     sm: sm, slug: slug, clients: clients, sendTo: sendTo, usersModule: usersModule,
     isMate: isMate, osUsers: osUsers,
     canAccessProject: function (ws) { return _requestAccess.canAccessProject(ws, slug); },

package/lib/public/app.js

@@ -507,6 +507,8 @@ import { initDebate, handleDebatePreparing, handleDebateStarted, handleDebateRes
     savedMainSlug: null,
     connected: false,
     fileReadRequest: null,
+    filePaneInstances: {},
+    activeFilePaneId: null,
     fileViewerIsPlantUml: false,
     plantUmlPreviewJob: null,
     wireframeDraft: null,

package/lib/public/css/issues.css

@@ -155,3 +155,6 @@
 .issue-github-matches a { flex: 1; min-width: 0; color: var(--text); text-decoration: none; overflow-wrap: anywhere; }
 .issue-github-matches a:hover { text-decoration: underline; }
 .issue-github-matches small { display: block; color: var(--text-muted); margin-bottom: 3px; }
+
+#issues-panel .issues-linear-link { display: inline-flex; align-items: center; gap: 5px; flex: 0 0 auto; height: 30px; padding: 0 8px; color: var(--text-secondary); font-size: 11px; white-space: nowrap; }
+#issues-panel .issues-linear-link .lucide { width: 12px; height: 12px; }

package/lib/public/css/pane.css

@@ -55,6 +55,11 @@ body.pane-mode #input-area {
   position: relative;
 }
 
+/* The workspace owns the canvas color behind every pane and expanded tool. */
+#main-panels:has(> #split-host.split-view-canvas.visible) {
+  background: var(--bg-alt);
+}
+
 #app.split-native-hidden {
   display: none !important;
 }
@@ -65,7 +70,6 @@ body.pane-mode #input-area {
   flex: 1;
   min-width: 0;
   min-height: 0;
-  background: var(--bg);
 }
 
 #split-host.visible {

package/lib/public/css/right-workbench.css

@@ -75,7 +75,6 @@
   #main-panels > [data-workbench-placement="docked"] :is(.terminal-header, .file-viewer-tabbar, .shared-browser-viewport) {
     background: var(--bg);
   }
-  #main-panels > #terminal-container[data-workbench-placement="docked"] #terminal-body { background: var(--bg); }
 }
 @media (max-width: 1023px) {
   #main-panels > [data-workbench-placement="docked"][data-workbench-active="false"] { display: none !important; }

package/lib/public/css/scheduled-tasks.css

@@ -29,6 +29,13 @@
 .scheduled-tasks-create-menu button:hover, .scheduled-tasks-create-menu button:focus-visible { outline: 0; background: var(--bg-alt); }
 .scheduled-task-default-ai { display: flex; align-items: center; justify-content: space-between; gap: 12px; padding: 9px 14px; border-bottom: 1px solid var(--border-subtle); background: var(--bg-alt); color: var(--text-dimmer); font-size: 11px; }
 .scheduled-task-default-ai button { border: 0; background: transparent; color: var(--accent); font: inherit; font-weight: 700; cursor: pointer; }
+.scheduled-tasks-toolbar { display: flex; align-items: center; gap: 12px; padding: 5px 8px; border-bottom: 1px solid var(--border-subtle); background: var(--bg-alt); flex-shrink: 0; }
+.scheduled-tasks-toolbar .scheduled-task-default-ai { flex: 1; min-width: 0; gap: 8px; padding: 0; border: 0; flex-wrap: wrap; }
+.scheduled-tasks-toolbar .scheduled-task-default-ai span { flex: 1; min-width: 120px; }
+.scheduled-tasks-toolbar .scheduled-task-default-ai button { padding: 0; white-space: nowrap; }
+.scheduled-tasks-toolbar .scheduled-tasks-create-group { height: 24px; }
+.scheduled-tasks-toolbar .scheduled-tasks-new { height: 24px; gap: 4px; padding: 0 7px; font-size: 11px; font-weight: 500; border-radius: 5px 0 0 5px; }
+.scheduled-tasks-toolbar .scheduled-tasks-new-menu { height: 24px; width: 23px; border-radius: 0 5px 5px 0; }
 .scheduled-tasks-list { flex: 1; min-height: 0; overflow-y: auto; }
 .scheduled-task-row { border-bottom: 1px solid var(--border-subtle); border-left: 2px solid transparent; }
 .scheduled-task-row:not(.paused) { border-left-color: var(--brand-green); }

package/lib/public/css/split-view-layout.css

@@ -79,7 +79,6 @@
 #split-host.split-view-canvas.visible {
   display: flex;
   padding: 7px;
-  background: var(--bg-alt);
   box-sizing: border-box;
 }
 .split-view-tree, .split-view-branch, .split-view-leaf {
@@ -107,8 +106,10 @@
 }
 .split-view-canvas .split-pane-title {
   min-width: 0;
-  flex: 1;
+  flex: 0 1 auto;
   max-width: none;
+  padding: 0;
+  margin-left: 0;
   font-size: 11px;
   font-weight: 500;
   overflow: hidden;
@@ -174,7 +175,7 @@ body.split-view-resizing .split-pane-frame { pointer-events: none; }
     align-content: center;
     gap: 4px;
   }
-  .split-view-canvas .split-pane-title { flex: 1 0 70px; }
+  .split-view-canvas .split-pane-title { flex: 0 1 auto; }
   .split-view-canvas .split-view-runtime { flex: 0 1 auto; max-width: 55%; min-width: 48px; }
 }
 .split-view-workers {
@@ -462,3 +463,36 @@ body.split-view-resizing .split-pane-frame { pointer-events: none; }
 
 /* Light reflects received WebSocket output, independent of processing state. */
 .split-view-worker-dot.io { background: var(--brand-green); box-shadow: 0 0 5px var(--brand-green); }
+
+/* Header whitespace is a handle; text and controls retain their own actions. */
+.split-pane-drag-space { flex: 1 1 12px; min-width: 12px; align-self: stretch; cursor: grab; touch-action: none; }
+.split-view-canvas .split-pane-header { cursor: grab; touch-action: none; }
+.split-view-canvas .split-pane-header[data-pane-loading="true"] { cursor: default; }
+body.is-dragging .split-pane-header, body.is-dragging .split-pane-drag-space { cursor: grabbing; }
+.split-view-canvas.split-view-drag-preview > .split-pane,
+.split-view-canvas.split-view-drag-preview > .split-view-divider,
+.split-view-canvas.split-view-drag-preview > .split-view-drop-preview {
+  transition: left 280ms cubic-bezier(.2,.75,.25,1), top 280ms cubic-bezier(.2,.75,.25,1),
+    width 280ms cubic-bezier(.2,.75,.25,1), height 280ms cubic-bezier(.2,.75,.25,1);
+}
+.split-view-canvas.split-view-drag-preview > .split-view-divider { pointer-events: none; opacity: .35; }
+.split-view-canvas.split-view-drag-preview > .split-view-drop-preview { background: transparent; }
+@media (prefers-reduced-motion: reduce) {
+  .split-view-canvas.split-view-drag-preview > .split-pane,
+  .split-view-canvas.split-view-drag-preview > .split-view-divider,
+  .split-view-canvas.split-view-drag-preview > .split-view-drop-preview { transition: none; }
+}
+
+.split-view-canvas > .split-pane.split-pane-drag-source { opacity: .72; }
+
+/* A shared tint marks the moving window without altering its content theme. */
+:is(.split-pane-drag-source, .tool-pane-drag-source)::after {
+  content: "";
+  position: absolute;
+  inset: 0;
+  z-index: 20;
+  border-radius: inherit;
+  background: color-mix(in srgb, var(--accent) 16%, transparent);
+  box-shadow: inset 0 0 0 1px var(--accent-20);
+  pointer-events: none;
+}