From 41b8fcba2f60c7bb1d8dee851980138b176e78fb Mon Sep 17 00:00:00 2001
From: Yuto Nishida <yuto@berkeley.edu>
Date: Fri, 17 Jul 2026 17:29:38 -0700
Subject: [PATCH] [papyrus] Per-session tabs + Connect/resume as a stateless
 silverwood projection

Render one tab per attached silverwood session (from 'session ls') instead of one terminal per workstream. A disconnected tab shows a Connect pane; Connect resumes that session (claude --resume <id>) in the checkout, gated on the advisory lock (a 409 carries the holder -> Force connect). A '+' starts a fresh session. The server runtime is now a per-session live-PTY registry ONLY (keyed by the claude session id, or a provisional uuid until the plugin hook reports it): it caches no durable data and re-reads silverwood on every GET /api/state, and the client reconciles that projection every ~1s (drag-safe, no invented state). Locks are acquired on connect / fresh-session record and released on disconnect/exit/SIGINT; status-update now records under session.workstreamId.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 experimental/papyrus/client/src/App.tsx       | 193 +++++-----
 .../client/src/components/NewSessionModal.tsx | 139 ++-----
 .../papyrus/client/src/components/Sidebar.tsx | 356 +++++++++++++-----
 .../client/src/components/Terminal.tsx        |   1 -
 .../papyrus/client/src/stores/useStore.ts     |  17 +-
 experimental/papyrus/server/index.ts          |  41 +-
 experimental/papyrus/server/routes/api.ts     | 204 +++++++---
 .../papyrus/server/services/sessionManager.ts | 149 +++++---
 .../papyrus/server/services/silverwood.ts     |  35 ++
 experimental/papyrus/server/types/index.ts    |  29 +-
 10 files changed, 719 insertions(+), 445 deletions(-)

diff --git a/experimental/papyrus/client/src/App.tsx b/experimental/papyrus/client/src/App.tsx
index fb940fa..82558ea 100644
--- a/experimental/papyrus/client/src/App.tsx
+++ b/experimental/papyrus/client/src/App.tsx
@@ -12,7 +12,7 @@ import {
 import "@xyflow/react/dist/style.css";
 import { Plus } from "lucide-react";
 
-import { useStore } from "./stores/useStore";
+import { useStore, AgentSession } from "./stores/useStore";
 import { AgentNode } from "./components/AgentNode/index";
 import { Sidebar } from "./components/Sidebar";
 import { NewSessionModal } from "./components/NewSessionModal";
@@ -31,21 +31,17 @@ function AppContent() {
     setLaunchCwd,
     setSelectedNodeId,
     setSidebarOpen,
-    addSession,
-    updateSession,
     agents,
     addAgentModalOpen,
     setAddAgentModalOpen,
-    newSessionModalOpen,
-    setNewSessionModalOpen,
-    newSessionForNodeId,
-    setNewSessionForNodeId,
-    sessions,
   } = useStore();
 
   const [nodes, setNodes, onNodesChange] = useNodesState(storeNodes);
   const positionUpdateTimeout = useRef<ReturnType<typeof setTimeout> | null>(null);
   const hasRestoredRef = useRef(false);
+  // True while a node is being dragged, so the reconcile loop doesn't touch nodes
+  // (and snap a drag back). Session/tab updates still flow.
+  const draggingRef = useRef(false);
 
   // Sync nodes with store
   useEffect(() => {
@@ -71,97 +67,94 @@ function AppContent() {
       .catch(console.error);
   }, [setAgents, setLaunchCwd]);
 
-  // Poll for status updates every second to catch any missed WebSocket messages
+  // Reconcile the client's view from silverwood every second. GET /api/state is a
+  // fresh projection (workstreams + per-session tabs + lock), so nodes/tabs/names
+  // appear, disappear, and update as the forest changes — including from other
+  // processes. The client invents no durable state. An existing node's position is
+  // never pulled from the server (positions flow client -> server on drag), so this
+  // never fights a drag; node mutations are also skipped while a drag is in flight.
   useEffect(() => {
-    const pollStatus = async () => {
+    if (agents.length === 0) return;
+    let cancelled = false;
+
+    const reconcile = async () => {
+      let serverNodes: any[];
       try {
-        const res = await fetch("/api/sessions");
-        if (res.ok) {
-          const sessionsData = await res.json();
-          const currentSessions = useStore.getState().sessions;
-          for (const sessionData of sessionsData) {
-            if (sessionData.nodeId && sessionData.status) {
-              const existing = currentSessions.get(sessionData.nodeId);
-              if (existing && existing.status !== sessionData.status) {
-                console.log(`[poll] Updating ${sessionData.nodeId} status: ${existing.status} -> ${sessionData.status}`);
-                updateSession(sessionData.nodeId, { status: sessionData.status });
-              }
-            }
-          }
-        }
-      } catch (e) {
-        // Ignore errors
+        const res = await fetch("/api/state");
+        if (!res.ok) return;
+        serverNodes = (await res.json()).nodes;
+      } catch {
+        return;
       }
-    };
-
-    // Poll immediately and then every second
-    pollStatus();
-    const interval = setInterval(pollStatus, 1000);
-    return () => clearInterval(interval);
-  }, [updateSession]);
-
-  // Restore sessions and categories after agents are loaded
-  useEffect(() => {
-    if (agents.length === 0 || hasRestoredRef.current) return;
-
-    Promise.all([
-      fetch("/api/sessions").then((res) => res.json()),
-      fetch("/api/state").then((res) => res.json()),
-    ])
-      .then(([sessions, { nodes: savedNodes }]) => {
-        const restoredNodes: any[] = [];
-
-        // Restore workstream nodes (each canvas node is a silverwood workstream)
-        sessions.forEach((session: any, index: number) => {
-          const saved = savedNodes?.find((n: any) => n.sessionId === session.sessionId);
-          const agent = agents.find((a) => a.id === session.agentId);
-          const position = saved?.position?.x
-            ? saved.position
-            : {
-                x: 100 + (index % 5) * 220,
-                y: 100 + Math.floor(index / 5) * 150,
-              };
-
-          addSession(session.nodeId, {
-            id: session.nodeId,
-            sessionId: session.sessionId,
-            agentId: session.agentId,
-            agentName: session.agentName,
-            command: session.command,
-            color: session.customColor || agent?.color || "#888",
-            createdAt: session.createdAt,
-            cwd: session.cwd,
-            originalCwd: session.originalCwd,
-            gitBranch: session.gitBranch,
-            status: session.status || "idle",
-            customName: session.customName,
-            customColor: session.customColor,
-            notes: session.notes,
-            isRestored: session.isRestored,
-            ticketId: session.ticketId,
-            ticketTitle: session.ticketTitle,
-          });
+      if (cancelled || !Array.isArray(serverNodes)) return;
+
+      const store = useStore.getState();
+      const dragging = draggingRef.current;
+      const serverIds = new Set<string>();
+
+      serverNodes.forEach((n: any, index: number) => {
+        serverIds.add(n.nodeId);
+        const agent = store.agents.find((a) => a.id === n.agentId);
+        const color = n.customColor || agent?.color || "#888";
+        const label = n.customName || n.agentName;
+        const sessionData = {
+          id: n.nodeId,
+          sessionId: n.sessionId,
+          agentId: n.agentId,
+          agentName: n.agentName,
+          command: n.command,
+          color,
+          createdAt: n.createdAt,
+          cwd: n.cwd,
+          status: (n.status || "idle") as AgentSession["status"],
+          customName: n.customName,
+          customColor: n.customColor,
+          notes: n.notes,
+          tabs: (n.sessions || []) as AgentSession["tabs"],
+        };
 
-          restoredNodes.push({
-            id: session.nodeId,
+        if (store.sessions.has(n.nodeId)) {
+          store.updateSession(n.nodeId, sessionData);
+          if (dragging) return;
+          // Reflect an external rename/recolor on the canvas node label.
+          const node = store.nodes.find((x) => x.id === n.nodeId);
+          if (node && (node.data?.label !== label || node.data?.color !== color)) {
+            store.updateNode(n.nodeId, { data: { ...node.data, label, color } });
+          }
+        } else if (!dragging) {
+          store.addSession(n.nodeId, sessionData);
+          const position =
+            n.position && typeof n.position.x === "number"
+              ? n.position
+              : { x: 100 + (index % 5) * 220, y: 100 + Math.floor(index / 5) * 150 };
+          store.addNode({
+            id: n.nodeId,
             type: "agent",
             position,
-            data: {
-              label: session.customName || session.agentName,
-              agentId: session.agentId,
-              color: session.customColor || agent?.color || "#888",
-              icon: agent?.icon || "cpu",
-              sessionId: session.sessionId,
-            },
+            data: { label, agentId: n.agentId, color, icon: agent?.icon || "cpu", sessionId: n.sessionId },
           });
-        });
+        }
+      });
+
+      // Drop workstreams that vanished (archived/deleted, possibly elsewhere).
+      if (!dragging) {
+        for (const id of [...store.sessions.keys()]) {
+          if (!serverIds.has(id)) {
+            store.removeSession(id);
+            store.removeNode(id);
+          }
+        }
+      }
+      hasRestoredRef.current = true;
+    };
 
-        hasRestoredRef.current = true;
-        setNodes(restoredNodes);
-        setStoreNodes(restoredNodes);
-      })
-      .catch(console.error);
-  }, [agents, addSession, setNodes, setStoreNodes]);
+    reconcile();
+    const interval = setInterval(reconcile, 1000);
+    return () => {
+      cancelled = true;
+      clearInterval(interval);
+    };
+  }, [agents.length]);
 
   // Helper to save all positions - accepts nodes directly to avoid sync issues
   const saveAllPositions = useCallback((nodesToSave?: typeof nodes) => {
@@ -201,6 +194,13 @@ function AppContent() {
   const handleNodesChange = useCallback((changes: NodeChange[]) => {
     onNodesChange(changes);
 
+    // Track drag state so the reconcile loop leaves nodes alone mid-drag.
+    for (const c of changes) {
+      if (c.type === "position" && "dragging" in c) {
+        draggingRef.current = c.dragging === true;
+      }
+    }
+
     const positionChanges = changes.filter(
       (c) => c.type === "position" && "dragging" in c && c.dragging === false
     );
@@ -297,16 +297,7 @@ function AppContent() {
         <Sidebar />
       </div>
 
-      <NewSessionModal
-        open={addAgentModalOpen || newSessionModalOpen}
-        onClose={() => {
-          setAddAgentModalOpen(false);
-          setNewSessionModalOpen(false);
-          setNewSessionForNodeId(null);
-        }}
-        existingSession={newSessionForNodeId ? sessions.get(newSessionForNodeId) : undefined}
-        existingNodeId={newSessionForNodeId || undefined}
-      />
+      <NewSessionModal open={addAgentModalOpen} onClose={() => setAddAgentModalOpen(false)} />
     </div>
   );
 }
diff --git a/experimental/papyrus/client/src/components/NewSessionModal.tsx b/experimental/papyrus/client/src/components/NewSessionModal.tsx
index ce54fae..cedd7ce 100644
--- a/experimental/papyrus/client/src/components/NewSessionModal.tsx
+++ b/experimental/papyrus/client/src/components/NewSessionModal.tsx
@@ -3,30 +3,20 @@ import { createPortal } from "react-dom";
 import { motion, AnimatePresence } from "framer-motion";
 import { X, GitBranch, Loader2, AlertCircle, Sparkles } from "lucide-react";
 import { useReactFlow } from "@xyflow/react";
-import { useStore, AgentSession } from "../stores/useStore";
 
 interface NewSessionModalProps {
   open: boolean;
   onClose: () => void;
-  // When set, we're re-spawning the terminal for an existing workstream node.
-  existingSession?: AgentSession;
-  existingNodeId?: string;
 }
 
 const GRID = 24;
 
 // Create a node = create a silverwood workstream from an https git URL (silverwood
-// clones its checkout), then spawn its Claude Code terminal. All durable state
-// lives in silverwood; the canvas coordinate is stored in the workstream's KV.
-export function NewSessionModal({
-  open,
-  onClose,
-  existingSession,
-  existingNodeId,
-}: NewSessionModalProps) {
-  const { addNode, addSession, updateSession } = useStore();
+// clones its checkout). All durable state lives in silverwood; the canvas
+// coordinate is stored in the workstream's KV. No optimistic node — the ~1s
+// reconcile adds it from the forest (server truth).
+export function NewSessionModal({ open, onClose }: NewSessionModalProps) {
   const reactFlowInstance = useReactFlow();
-  const isReplacing = !!existingNodeId && !!existingSession;
 
   const [name, setName] = useState("");
   const [source, setSource] = useState("");
@@ -54,26 +44,6 @@ export function NewSessionModal({
     };
   };
 
-  const handleSpawnFresh = async () => {
-    if (!existingNodeId || !existingSession) return;
-    setIsBusy(true);
-    setError(null);
-    try {
-      const res = await fetch(`/api/sessions/${existingSession.sessionId}/restart`, {
-        method: "POST",
-      });
-      if (!res.ok) {
-        throw new Error((await res.json()).error || "Failed to spawn terminal");
-      }
-      updateSession(existingNodeId, { status: "running", isRestored: false });
-      onClose();
-    } catch (e: any) {
-      setError(e.message);
-    } finally {
-      setIsBusy(false);
-    }
-  };
-
   const handleCreate = async () => {
     if (!name.trim() || !source.trim()) return;
     setIsBusy(true);
@@ -87,32 +57,6 @@ export function NewSessionModal({
       });
       const data = await res.json();
       if (!res.ok) throw new Error(data.error || "Failed to create workstream");
-
-      const sessionId: string = data.sessionId;
-      addNode({
-        id: sessionId,
-        type: "agent",
-        position,
-        data: {
-          label: name.trim(),
-          agentId: "claude",
-          color: "#F97316",
-          icon: "sparkles",
-          sessionId,
-        },
-      });
-      addSession(sessionId, {
-        id: sessionId,
-        sessionId,
-        agentId: "claude",
-        agentName: "Claude Code",
-        command: "claude",
-        color: "#F97316",
-        createdAt: new Date().toISOString(),
-        cwd: data.cwd || "",
-        status: data.checkoutState === "ready" ? "running" : "idle",
-        customName: name.trim(),
-      });
       onClose();
     } catch (e: any) {
       setError(e.message);
@@ -142,9 +86,7 @@ export function NewSessionModal({
               <div className="rounded-xl bg-surface border border-border shadow-2xl overflow-hidden flex flex-col">
                 {/* Header */}
                 <div className="px-5 py-4 border-b border-border flex items-center justify-between">
-                  <h2 className="text-base font-semibold text-white">
-                    {isReplacing ? "Spawn Fresh Terminal" : "New Workstream"}
-                  </h2>
+                  <h2 className="text-base font-semibold text-white">New Workstream</h2>
                   <button
                     onClick={onClose}
                     className="w-7 h-7 rounded flex items-center justify-center text-zinc-500 hover:text-white hover:bg-surface-active transition-colors"
@@ -155,43 +97,34 @@ export function NewSessionModal({
 
                 {/* Body */}
                 <div className="p-5 space-y-4">
-                  {isReplacing ? (
-                    <p className="text-sm text-zinc-400">
-                      Spawn a fresh Claude Code terminal in this workstream's checkout.
-                      The workstream and its history in silverwood are unchanged.
+                  <div className="space-y-2">
+                    <label className="text-xs text-zinc-500">Name</label>
+                    <input
+                      type="text"
+                      value={name}
+                      onChange={(e) => setName(e.target.value)}
+                      placeholder="auth-refactor"
+                      autoFocus
+                      className="w-full px-3 py-2 rounded-md bg-canvas border border-border text-white text-sm placeholder-zinc-600 focus:outline-none focus:border-zinc-500 transition-colors"
+                    />
+                  </div>
+                  <div className="space-y-2">
+                    <label className="text-xs text-zinc-500 flex items-center gap-1.5">
+                      <GitBranch className="w-3 h-3" />
+                      Source (HTTPS git URL)
+                    </label>
+                    <input
+                      type="text"
+                      value={source}
+                      onChange={(e) => setSource(e.target.value)}
+                      placeholder="https://github.com/owner/repo.git"
+                      className="w-full px-3 py-2 rounded-md bg-canvas border border-border text-white text-sm placeholder-zinc-600 focus:outline-none focus:border-zinc-500 transition-colors font-mono"
+                    />
+                    <p className="text-[10px] text-zinc-600">
+                      silverwood clones this into a jj-colocated checkout, then Claude Code
+                      runs there. This can take a moment.
                     </p>
-                  ) : (
-                    <>
-                      <div className="space-y-2">
-                        <label className="text-xs text-zinc-500">Name</label>
-                        <input
-                          type="text"
-                          value={name}
-                          onChange={(e) => setName(e.target.value)}
-                          placeholder="auth-refactor"
-                          autoFocus
-                          className="w-full px-3 py-2 rounded-md bg-canvas border border-border text-white text-sm placeholder-zinc-600 focus:outline-none focus:border-zinc-500 transition-colors"
-                        />
-                      </div>
-                      <div className="space-y-2">
-                        <label className="text-xs text-zinc-500 flex items-center gap-1.5">
-                          <GitBranch className="w-3 h-3" />
-                          Source (HTTPS git URL)
-                        </label>
-                        <input
-                          type="text"
-                          value={source}
-                          onChange={(e) => setSource(e.target.value)}
-                          placeholder="https://github.com/owner/repo.git"
-                          className="w-full px-3 py-2 rounded-md bg-canvas border border-border text-white text-sm placeholder-zinc-600 focus:outline-none focus:border-zinc-500 transition-colors font-mono"
-                        />
-                        <p className="text-[10px] text-zinc-600">
-                          silverwood clones this into a jj-colocated checkout, then Claude Code
-                          runs there. This can take a moment.
-                        </p>
-                      </div>
-                    </>
-                  )}
+                  </div>
 
                   {error && (
                     <div className="p-3 rounded-md bg-red-500/10 border border-red-500/20 flex items-start gap-2">
@@ -210,17 +143,15 @@ export function NewSessionModal({
                     Cancel
                   </button>
                   <button
-                    onClick={isReplacing ? handleSpawnFresh : handleCreate}
-                    disabled={isBusy || (!isReplacing && (!name.trim() || !source.trim()))}
+                    onClick={handleCreate}
+                    disabled={isBusy || !name.trim() || !source.trim()}
                     className="px-4 py-1.5 rounded-md text-sm font-medium text-canvas bg-white hover:bg-zinc-100 disabled:opacity-50 disabled:cursor-not-allowed transition-colors flex items-center gap-1.5"
                   >
                     {isBusy ? (
                       <>
                         <Loader2 className="w-4 h-4 animate-spin" />
-                        {isReplacing ? "Spawning..." : "Cloning..."}
+                        Cloning...
                       </>
-                    ) : isReplacing ? (
-                      "Spawn Fresh"
                     ) : (
                       <>
                         <Sparkles className="w-4 h-4" />
diff --git a/experimental/papyrus/client/src/components/Sidebar.tsx b/experimental/papyrus/client/src/components/Sidebar.tsx
index f78f6a0..f44e60c 100644
--- a/experimental/papyrus/client/src/components/Sidebar.tsx
+++ b/experimental/papyrus/client/src/components/Sidebar.tsx
@@ -6,7 +6,11 @@ import {
   Clock,
   Folder,
   Edit3,
-  RotateCcw,
+  Plus,
+  Plug,
+  Power,
+  Lock,
+  Loader2,
   Sparkles,
   Code,
   Cpu,
@@ -17,7 +21,7 @@ import {
   Wand2,
   GitBranch,
 } from "lucide-react";
-import { useStore, AgentStatus } from "../stores/useStore";
+import { useStore, AgentStatus, SessionTab } from "../stores/useStore";
 import { Terminal } from "./Terminal";
 
 const statusConfig: Record<AgentStatus, { label: string; color: string }> = {
@@ -44,6 +48,13 @@ const iconOptions = [
   { id: "wand2", icon: Wand2, label: "Wand" },
 ];
 
+// A short, human-legible label for a session tab.
+function tabLabel(t: SessionTab): string {
+  if (t.name && t.name !== t.claudeSessionId && t.name !== "claude") return t.name;
+  const id = t.claudeSessionId || t.sessionId;
+  return id.length > 8 ? id.slice(0, 8) : id;
+}
+
 export function Sidebar() {
   const {
     sidebarOpen,
@@ -54,34 +65,89 @@ export function Sidebar() {
     updateSession,
     updateNode,
     nodes,
-    setNewSessionModalOpen,
-    setNewSessionForNodeId,
   } = useStore();
 
   const session = selectedNodeId ? sessions.get(selectedNodeId) : null;
-  const node = selectedNodeId ? nodes.find(n => n.id === selectedNodeId) : null;
+  const node = selectedNodeId ? nodes.find((n) => n.id === selectedNodeId) : null;
 
   const [isEditing, setIsEditing] = useState(false);
   const [editName, setEditName] = useState("");
   const [editNotes, setEditNotes] = useState("");
   const [editColor, setEditColor] = useState("");
   const [editIcon, setEditIcon] = useState("");
-  const [terminalKey, setTerminalKey] = useState(0);
 
-  // Reset edit state when session changes (but NOT when nodes change)
+  const [activeTabId, setActiveTabId] = useState<string | undefined>(undefined);
+  // Optimism: an action's server-confirmed result, shown until the ~1s reconcile
+  // reflects it (mount-from-response). { sessionId -> partial tab override }.
+  const [pending, setPending] = useState<Record<string, Partial<SessionTab>>>({});
+  const [connectError, setConnectError] = useState<string | null>(null);
+  const [busy, setBusy] = useState(false);
+
+  const storeTabs: SessionTab[] = session?.tabs ?? [];
+
+  // The tab list: the server projection, with local optimism merged over it.
+  const tabs: SessionTab[] = (() => {
+    const byId = new Map<string, SessionTab>(storeTabs.map((t) => [t.sessionId, { ...t }]));
+    for (const [sid, ov] of Object.entries(pending)) {
+      const ex = byId.get(sid);
+      if (ex) byId.set(sid, { ...ex, ...ov });
+      else
+        byId.set(sid, {
+          sessionId: sid,
+          name: "claude",
+          createdAt: new Date().toISOString(),
+          kind: "claude-code",
+          connected: true,
+          status: "running",
+          lock: null,
+          ...ov,
+        });
+    }
+    return [...byId.values()];
+  })();
+
+  // Reset node-level edit buffers when the selected workstream changes.
   useEffect(() => {
     if (session) {
       setEditName(session.customName || session.agentName);
       setEditNotes(session.notes || "");
       setEditColor(session.customColor || session.color);
-      const currentNode = nodes.find(n => n.id === selectedNodeId);
-      const nodeIcon = currentNode?.data?.icon;
-      setEditIcon(typeof nodeIcon === 'string' ? nodeIcon : "cpu");
+      const nodeIcon = node?.data?.icon;
+      setEditIcon(typeof nodeIcon === "string" ? nodeIcon : "cpu");
     }
     setIsEditing(false);
-    // Force terminal recreation when session changes
-    setTerminalKey(k => k + 1);
-  }, [session?.sessionId]); // Removed nodes and selectedNodeId to prevent closing on updates
+    setConnectError(null);
+  }, [selectedNodeId]);
+
+  // Default/clamp the active tab to one that exists.
+  useEffect(() => {
+    if (tabs.length === 0) {
+      if (activeTabId !== undefined) setActiveTabId(undefined);
+      return;
+    }
+    if (!activeTabId || !tabs.some((t) => t.sessionId === activeTabId)) {
+      setActiveTabId(tabs[0].sessionId);
+    }
+  }, [tabs, activeTabId]);
+
+  // Drop optimism once the reconcile agrees (server truth caught up).
+  useEffect(() => {
+    setPending((p) => {
+      const keys = Object.keys(p);
+      if (keys.length === 0) return p;
+      let changed = false;
+      const next: Record<string, Partial<SessionTab>> = {};
+      for (const sid of keys) {
+        const t = storeTabs.find((x) => x.sessionId === sid);
+        const settled = t && (p[sid].connected === undefined || t.connected === p[sid].connected);
+        if (settled) changed = true;
+        else next[sid] = p[sid];
+      }
+      return changed ? next : p;
+    });
+  }, [storeTabs]);
+
+  const activeTab = tabs.find((t) => t.sessionId === activeTabId);
 
   const handleClose = () => {
     setSidebarOpen(false);
@@ -89,16 +155,73 @@ export function Sidebar() {
     setIsEditing(false);
   };
 
-  const handleNewSession = () => {
-    if (selectedNodeId) {
-      setNewSessionForNodeId(selectedNodeId);
-      setNewSessionModalOpen(true);
+  const connect = async (tab: SessionTab, force = false) => {
+    if (!selectedNodeId) return;
+    setBusy(true);
+    setConnectError(null);
+    setActiveTabId(tab.sessionId);
+    try {
+      const res = await fetch(`/api/sessions/${selectedNodeId}/sessions/connect`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ sessionId: tab.claudeSessionId ?? tab.sessionId, force }),
+      });
+      const data = await res.json().catch(() => ({}));
+      if (res.status === 409) {
+        setConnectError(data.holder ? `In use by ${data.holder}` : data.error || "Locked");
+        return;
+      }
+      if (!res.ok) {
+        setConnectError(data.error || "Failed to connect");
+        return;
+      }
+      setPending((p) => ({ ...p, [data.sessionId]: { connected: true } }));
+      setActiveTabId(data.sessionId);
+    } catch (e: any) {
+      setConnectError(e.message);
+    } finally {
+      setBusy(false);
+    }
+  };
+
+  const newTab = async () => {
+    if (!selectedNodeId) return;
+    setBusy(true);
+    setConnectError(null);
+    try {
+      const res = await fetch(`/api/sessions/${selectedNodeId}/sessions`, { method: "POST" });
+      const data = await res.json().catch(() => ({}));
+      if (!res.ok) {
+        setConnectError(data.error || "Failed to start session");
+        return;
+      }
+      setPending((p) => ({ ...p, [data.sessionId]: { connected: true } }));
+      setActiveTabId(data.sessionId);
+    } catch (e: any) {
+      setConnectError(e.message);
+    } finally {
+      setBusy(false);
+    }
+  };
+
+  const disconnect = async (tab: SessionTab) => {
+    if (!selectedNodeId) return;
+    setPending((p) => {
+      const n = { ...p };
+      delete n[tab.sessionId];
+      return n;
+    });
+    try {
+      await fetch(`/api/sessions/${selectedNodeId}/sessions/${tab.sessionId}/disconnect`, {
+        method: "POST",
+      });
+    } catch {
+      // The reconcile loop will reflect the real state.
     }
   };
 
   const displayColor = editColor || session?.customColor || session?.color || "#888";
   const statusInfo = statusConfig[session?.status || "idle"];
-  const isDisconnected = session?.status === "disconnected";
 
   return (
     <AnimatePresence>
@@ -129,13 +252,13 @@ export function Sidebar() {
                   <span className="text-[10px] text-zinc-500">{statusInfo.label}</span>
                 </div>
               </div>
-              
+
               <div className="flex items-center gap-1 flex-shrink-0">
                 <button
                   onClick={() => setIsEditing(!isEditing)}
                   className={`w-7 h-7 rounded flex items-center justify-center transition-colors ${
-                    isEditing 
-                      ? "text-white bg-surface-active" 
+                    isEditing
+                      ? "text-white bg-surface-active"
                       : "text-zinc-500 hover:text-white hover:bg-surface-active"
                   }`}
                 >
@@ -151,38 +274,6 @@ export function Sidebar() {
             </div>
           </div>
 
-          {/* Disconnected banner */}
-          {isDisconnected && (
-            <div className="flex-shrink-0 px-4 py-3 bg-red-500/10 border-b border-red-500/20">
-              <div className="space-y-3">
-                <div>
-                  <p className="text-sm text-red-400 font-medium">Session Disconnected</p>
-                  <p className="text-xs text-red-400/70 mt-0.5">The agent was stopped. Start a new session.</p>
-                </div>
-                <button
-                  onClick={handleNewSession}
-                  className="w-full flex items-center justify-center gap-2 px-3 py-1.5 rounded-md bg-red-500 text-white text-sm font-medium hover:bg-red-600 transition-colors"
-                >
-                  <RotateCcw className="w-3.5 h-3.5" />
-                  New Session
-                </button>
-              </div>
-            </div>
-          )}
-
-          {/* Session Management Controls */}
-          {!isDisconnected && !isEditing && (
-            <div className="flex-shrink-0 px-4 py-2 border-b border-border">
-              <button
-                onClick={handleNewSession}
-                className="w-full flex items-center justify-center gap-2 px-3 py-1.5 rounded-md bg-surface-active text-zinc-300 text-xs font-medium hover:bg-zinc-700 transition-colors"
-              >
-                <RotateCcw className="w-3 h-3" />
-                New Session
-              </button>
-            </div>
-          )}
-
           {/* Edit Panel */}
           <AnimatePresence>
             {isEditing && (
@@ -201,7 +292,6 @@ export function Sidebar() {
                       onChange={(e) => {
                         const newName = e.target.value;
                         setEditName(newName);
-                        // Instant update
                         if (selectedNodeId && session) {
                           const customName = newName !== session.agentName ? newName : undefined;
                           updateSession(selectedNodeId, { customName });
@@ -210,8 +300,7 @@ export function Sidebar() {
                               data: { ...node.data, label: newName },
                             });
                           }
-                          // Persist to API
-                          fetch(`/api/sessions/${session.sessionId}`, {
+                          fetch(`/api/sessions/${selectedNodeId}`, {
                             method: "PATCH",
                             headers: { "Content-Type": "application/json" },
                             body: JSON.stringify({ customName }),
@@ -221,7 +310,7 @@ export function Sidebar() {
                       className="mt-1 w-full px-3 py-2 rounded-md bg-canvas border border-border text-white text-sm focus:outline-none focus:border-zinc-500 transition-colors"
                     />
                   </div>
-                  
+
                   <div>
                     <label className="text-[10px] text-zinc-500 uppercase tracking-wider">Color</label>
                     <div className="mt-2 flex flex-wrap gap-2">
@@ -230,7 +319,6 @@ export function Sidebar() {
                           key={color}
                           onClick={() => {
                             setEditColor(color);
-                            // Instant update
                             if (selectedNodeId && session) {
                               updateSession(selectedNodeId, { customColor: color });
                               if (node) {
@@ -238,8 +326,7 @@ export function Sidebar() {
                                   data: { ...node.data, color },
                                 });
                               }
-                              // Persist to API
-                              fetch(`/api/sessions/${session.sessionId}`, {
+                              fetch(`/api/sessions/${selectedNodeId}`, {
                                 method: "PATCH",
                                 headers: { "Content-Type": "application/json" },
                                 body: JSON.stringify({ customColor: color }),
@@ -265,7 +352,6 @@ export function Sidebar() {
                           key={id}
                           onClick={() => {
                             setEditIcon(id);
-                            // Instant update
                             if (selectedNodeId && node) {
                               updateNode(selectedNodeId, {
                                 data: { ...node.data, icon: id },
@@ -277,7 +363,7 @@ export function Sidebar() {
                               ? "ring-2 ring-white ring-offset-2 ring-offset-canvas-dark scale-110 bg-white/10"
                               : "hover:scale-110 hover:bg-white/5 bg-canvas"
                           }`}
-                          style={{ borderColor: editIcon === id ? editColor : "#333", borderWidth: '1px' }}
+                          style={{ borderColor: editIcon === id ? editColor : "#333", borderWidth: "1px" }}
                         >
                           <IconComponent
                             className="w-4 h-4"
@@ -287,20 +373,15 @@ export function Sidebar() {
                       ))}
                     </div>
                   </div>
-                  
+
                   <div>
                     <label className="text-[10px] text-zinc-500 uppercase tracking-wider">Notes</label>
                     <textarea
                       value={editNotes}
-                      onChange={(e) => {
-                        const newNotes = e.target.value;
-                        setEditNotes(newNotes);
-                        // Update with debounce would be better, but instant for now
-                      }}
+                      onChange={(e) => setEditNotes(e.target.value)}
                       onBlur={() => {
-                        // Save notes on blur
                         if (selectedNodeId && session) {
-                          fetch(`/api/sessions/${session.sessionId}`, {
+                          fetch(`/api/sessions/${selectedNodeId}`, {
                             method: "PATCH",
                             headers: { "Content-Type": "application/json" },
                             body: JSON.stringify({ notes: editNotes || undefined }),
@@ -318,29 +399,118 @@ export function Sidebar() {
             )}
           </AnimatePresence>
 
-          {/* Terminal */}
+          {/* Session tabs */}
+          <div className="flex-shrink-0 flex items-stretch gap-1 px-2 pt-2 border-b border-border overflow-x-auto">
+            {tabs.map((t) => {
+              const lockedByOther = t.lock && !t.lock.mine;
+              const dot = t.connected ? "#22C55E" : lockedByOther ? "#FBBF24" : "#6B7280";
+              return (
+                <button
+                  key={t.sessionId}
+                  onClick={() => setActiveTabId(t.sessionId)}
+                  title={t.claudeSessionId || t.sessionId}
+                  className={`flex items-center gap-1.5 px-3 py-1.5 rounded-t-md text-xs whitespace-nowrap transition-colors ${
+                    t.sessionId === activeTabId
+                      ? "bg-[#0d0d0d] text-white border-b-2 border-white"
+                      : "text-zinc-400 hover:text-white hover:bg-surface-active"
+                  }`}
+                >
+                  <span className="w-1.5 h-1.5 rounded-full flex-shrink-0" style={{ backgroundColor: dot }} />
+                  <span className="max-w-[120px] truncate">{tabLabel(t)}</span>
+                  {lockedByOther && <Lock className="w-3 h-3 text-amber-400 flex-shrink-0" />}
+                </button>
+              );
+            })}
+            <button
+              onClick={newTab}
+              disabled={busy}
+              title="Start a new session"
+              className="flex items-center justify-center px-2 py-1.5 rounded-t-md text-zinc-400 hover:text-white hover:bg-surface-active transition-colors disabled:opacity-50"
+            >
+              <Plus className="w-3.5 h-3.5" />
+            </button>
+          </div>
+
+          {/* Active session pane */}
           <div className="flex-1 flex flex-col min-h-0">
-            <div className="flex-shrink-0 px-4 py-2 border-b border-border flex items-center justify-between">
-              <div className="flex items-center gap-2">
-                <TerminalIcon className="w-3.5 h-3.5 text-zinc-500" />
-                <span className="text-xs text-zinc-500">Terminal</span>
+            {!activeTab ? (
+              <div className="flex-1 flex items-center justify-center p-6 text-center">
+                <div>
+                  <p className="text-sm text-zinc-400">No sessions yet</p>
+                  <button
+                    onClick={newTab}
+                    disabled={busy}
+                    className="mt-3 inline-flex items-center gap-2 px-3 py-1.5 rounded-md bg-white text-canvas text-sm font-medium hover:bg-zinc-100 disabled:opacity-50 transition-colors"
+                  >
+                    {busy ? <Loader2 className="w-3.5 h-3.5 animate-spin" /> : <Plus className="w-3.5 h-3.5" />}
+                    Start a session
+                  </button>
+                </div>
               </div>
-              <div className="flex items-center gap-1">
-                <div className="w-2.5 h-2.5 rounded-full bg-[#FF5F56]" />
-                <div className="w-2.5 h-2.5 rounded-full bg-[#FFBD2E]" />
-                <div className="w-2.5 h-2.5 rounded-full bg-[#27CA40]" />
+            ) : activeTab.connected ? (
+              <>
+                <div className="flex-shrink-0 px-4 py-2 border-b border-border flex items-center justify-between">
+                  <div className="flex items-center gap-2">
+                    <TerminalIcon className="w-3.5 h-3.5 text-zinc-500" />
+                    <span className="text-xs text-zinc-500">Terminal</span>
+                  </div>
+                  <button
+                    onClick={() => disconnect(activeTab)}
+                    title="Disconnect (keeps the session)"
+                    className="flex items-center gap-1.5 px-2 py-1 rounded text-[11px] text-zinc-400 hover:text-white hover:bg-surface-active transition-colors"
+                  >
+                    <Power className="w-3 h-3" />
+                    Disconnect
+                  </button>
+                </div>
+                <div className="flex-1 min-h-0 bg-[#0d0d0d]">
+                  <Terminal
+                    key={activeTab.sessionId}
+                    sessionId={activeTab.sessionId}
+                    color={displayColor}
+                    nodeId={selectedNodeId!}
+                  />
+                </div>
+              </>
+            ) : (
+              <div className="flex-1 flex items-center justify-center p-6">
+                <div className="w-full max-w-sm space-y-3 text-center">
+                  <Plug className="w-6 h-6 text-zinc-500 mx-auto" />
+                  <div>
+                    <p className="text-sm text-white font-medium">{tabLabel(activeTab)}</p>
+                    <p className="text-xs text-zinc-500 mt-0.5">
+                      Disconnected — connecting resumes this Claude Code conversation.
+                    </p>
+                  </div>
+                  {activeTab.lock && !activeTab.lock.mine ? (
+                    <div className="space-y-2">
+                      <div className="flex items-center justify-center gap-1.5 text-xs text-amber-400">
+                        <Lock className="w-3.5 h-3.5" />
+                        In use by {activeTab.lock.holder}
+                      </div>
+                      <button
+                        onClick={() => connect(activeTab, true)}
+                        disabled={busy}
+                        className="w-full flex items-center justify-center gap-2 px-3 py-1.5 rounded-md bg-amber-500 text-black text-sm font-medium hover:bg-amber-400 disabled:opacity-50 transition-colors"
+                      >
+                        {busy ? <Loader2 className="w-3.5 h-3.5 animate-spin" /> : <Power className="w-3.5 h-3.5" />}
+                        Force connect
+                      </button>
+                    </div>
+                  ) : (
+                    <button
+                      onClick={() => connect(activeTab)}
+                      disabled={busy}
+                      className="w-full flex items-center justify-center gap-2 px-3 py-1.5 rounded-md bg-white text-canvas text-sm font-medium hover:bg-zinc-100 disabled:opacity-50 transition-colors"
+                    >
+                      {busy ? <Loader2 className="w-3.5 h-3.5 animate-spin" /> : <Plug className="w-3.5 h-3.5" />}
+                      Connect
+                    </button>
+                  )}
+                  {connectError && <p className="text-xs text-red-400">{connectError}</p>}
+                </div>
               </div>
-            </div>
-
-            <div className="flex-1 min-h-0 bg-[#0d0d0d]">
-              <Terminal
-                key={`${session.sessionId}-${terminalKey}`}
-                sessionId={session.sessionId}
-                color={displayColor}
-                nodeId={selectedNodeId!}
-              />
-            </div>
-
+            )}
           </div>
 
           {/* Details */}
@@ -362,16 +532,14 @@ export function Sidebar() {
                 <Folder className="w-3 h-3 text-zinc-600 flex-shrink-0" />
                 <span className="text-zinc-500">Directory</span>
                 <span className="text-zinc-400 font-mono ml-auto truncate max-w-[180px]" title={session.cwd}>
-                  {session.cwd.split('/').slice(-2).join('/')}
+                  {session.cwd.split("/").slice(-2).join("/")}
                 </span>
               </div>
               {session.gitBranch && (
                 <div className="flex items-center gap-2 text-xs">
                   <GitBranch className="w-3 h-3 text-zinc-600 flex-shrink-0" />
                   <span className="text-zinc-500">Branch</span>
-                  <span className="text-purple-400 font-mono ml-auto">
-                    {session.gitBranch}
-                  </span>
+                  <span className="text-purple-400 font-mono ml-auto">{session.gitBranch}</span>
                 </div>
               )}
             </div>
diff --git a/experimental/papyrus/client/src/components/Terminal.tsx b/experimental/papyrus/client/src/components/Terminal.tsx
index 9ea1059..99db04a 100644
--- a/experimental/papyrus/client/src/components/Terminal.tsx
+++ b/experimental/papyrus/client/src/components/Terminal.tsx
@@ -117,7 +117,6 @@ export function Terminal({ sessionId, color, nodeId }: TerminalProps) {
             // Handle status updates from plugin hooks
             updateSession(nodeId, {
               status: msg.status as AgentStatus,
-              isRestored: msg.isRestored,
               currentTool: msg.currentTool,
             });
           }
diff --git a/experimental/papyrus/client/src/stores/useStore.ts b/experimental/papyrus/client/src/stores/useStore.ts
index 155d237..a7b3b8c 100644
--- a/experimental/papyrus/client/src/stores/useStore.ts
+++ b/experimental/papyrus/client/src/stores/useStore.ts
@@ -12,6 +12,20 @@ export interface Agent {
 
 export type AgentStatus = "running" | "waiting_input" | "tool_calling" | "idle" | "disconnected" | "error";
 
+// One attached silverwood session = one tab. Projected from `session ls` + the
+// server's live-PTY overlay + the advisory lock. `sessionId` is the runtime key
+// used for the terminal WebSocket; `claudeSessionId` is the durable id to resume.
+export interface SessionTab {
+  sessionId: string;
+  claudeSessionId?: string;
+  name: string;
+  createdAt: string;
+  kind: string;
+  connected: boolean;
+  status: AgentStatus;
+  lock?: { holder: string; mine: boolean } | null;
+}
+
 export interface AgentSession {
   id: string;
   sessionId: string;
@@ -27,7 +41,8 @@ export interface AgentSession {
   customName?: string;
   customColor?: string;
   notes?: string;
-  isRestored?: boolean;
+  // The workstream's attached sessions, one tab each (server projection).
+  tabs?: SessionTab[];
   // Linear ticket info
   ticketId?: string;
   ticketTitle?: string;
diff --git a/experimental/papyrus/server/index.ts b/experimental/papyrus/server/index.ts
index 8ec1983..353c76b 100644
--- a/experimental/papyrus/server/index.ts
+++ b/experimental/papyrus/server/index.ts
@@ -3,7 +3,8 @@ import { cors } from "hono/cors";
 import { serveStatic } from "hono/bun";
 import type { ServerWebSocket } from "bun";
 import { apiRoutes } from "./routes/api";
-import { sessions } from "./services/sessionManager";
+import { sessions, resolveRuntime, HOLDER } from "./services/sessionManager";
+import * as sw from "./services/silverwood";
 import { PORT } from "./config";
 import type { WebSocketData } from "./types";
 
@@ -32,10 +33,12 @@ Bun.serve<WebSocketData>({
       const sessionId = url.searchParams.get("sessionId");
       if (!sessionId) return new Response("Session ID required", { status: 400 });
 
-      const session = sessions.get(sessionId);
-      if (!session) return new Response("Session not found", { status: 404 });
+      const r = resolveRuntime(sessionId);
+      if (!r) return new Response("Session not found", { status: 404 });
 
-      const upgraded = server.upgrade(req, { data: { sessionId } });
+      // Key the socket by the resolved registry key (a fresh session is addressed
+      // by a provisional id but registered under it).
+      const upgraded = server.upgrade(req, { data: { sessionId: r[0] } });
       if (upgraded) return undefined;
       return new Response("WebSocket upgrade failed", { status: 400 });
     }
@@ -55,21 +58,12 @@ Bun.serve<WebSocketData>({
       log(`\x1b[38;5;245m[ws]\x1b[0m Connected to ${sessionId}`);
       session.clients.add(ws);
 
-      if (session.outputBuffer.length > 0 && !session.isRestored && session.pty) {
-        const history = session.outputBuffer.join("");
-        ws.send(JSON.stringify({ type: "output", data: history }));
-      } else if (session.isRestored || !session.pty) {
-        ws.send(JSON.stringify({
-          type: "output",
-          data: "\x1b[38;5;245mSession was disconnected.\r\nClick \"Spawn Fresh\" to start a new session.\x1b[0m\r\n"
-        }));
+      // Replay scrollback so a (re)connecting client sees the live terminal.
+      if (session.outputBuffer.length > 0) {
+        ws.send(JSON.stringify({ type: "output", data: session.outputBuffer.join("") }));
       }
 
-      ws.send(JSON.stringify({
-        type: "status",
-        status: session.status,
-        isRestored: session.isRestored
-      }));
+      ws.send(JSON.stringify({ type: "status", status: session.status }));
     },
     message(ws, message) {
       const { sessionId } = ws.data;
@@ -113,10 +107,13 @@ log(`\x1b[38;5;245m[server]\x1b[0m Forest: ${process.env.SILVERWOOD_FOREST_PATH
 // The canvas is rebuilt from silverwood on demand (GET /api/state); there is no
 // startup restore and nothing to autosave — all durable state lives in silverwood.
 
-// Cleanup on exit: kill terminals (no disk state to flush).
-process.on("SIGINT", () => {
-  for (const [, session] of sessions) {
-    if (session.pty) session.pty.kill();
-  }
+// Cleanup on exit: release advisory locks this instance holds (best-effort), then
+// kill terminals. A hard crash skips this; a stuck lock is recovered via a force-steal.
+process.on("SIGINT", async () => {
+  const held = [...sessions.values()].filter((s) => s.holdsLock && s.claudeSessionId);
+  await Promise.allSettled(
+    held.map((s) => sw.sessionUnlock(s.workstreamId, s.claudeSessionId!, HOLDER)),
+  );
+  for (const [, session] of sessions) session.pty.kill();
   process.exit(0);
 });
diff --git a/experimental/papyrus/server/routes/api.ts b/experimental/papyrus/server/routes/api.ts
index 652461b..0eac86e 100644
--- a/experimental/papyrus/server/routes/api.ts
+++ b/experimental/papyrus/server/routes/api.ts
@@ -1,10 +1,13 @@
 import { Hono } from "hono";
 import type { Agent } from "../types";
+import { randomUUID } from "crypto";
 import {
   sessions,
   spawnTerminal,
   killTerminal,
-  ensureDormant,
+  resolveRuntime,
+  pruneWorkstreams,
+  HOLDER,
 } from "../services/sessionManager";
 import * as sw from "../services/silverwood";
 import {
@@ -46,28 +49,73 @@ apiRoutes.get("/agents", (c) => {
 
 // ---- node model: a canvas node IS a silverwood workstream ----
 
-// Project a workstream (+ its runtime terminal, if any) into the node shape the
-// client renders. Presentation state comes from papyrus's KV namespace; the
-// display name is the workstream name.
-function buildNode(ws: sw.Workstream) {
+// Project a workstream into the node the client renders. Every durable field is
+// read fresh from silverwood; a per-session `sessions[]` list overlays the live
+// PTY registry ("connected") and the advisory lock ("mine" = held by this
+// instance). papyrus caches no durable data — this is a pure projection.
+async function buildNode(ws: sw.Workstream) {
   const kv = ws.kv?.[sw.PAPYRUS_NS] || {};
-  const runtime = sessions.get(ws.id);
   const cwd = sw.checkoutLocation(ws) || "";
   const cstate = sw.checkoutState(ws);
-  const status = runtime?.pty
-    ? runtime.status
+
+  // Live PTYs belonging to this workstream, from the registry.
+  const runtimes = [...sessions].filter(([, s]) => s.workstreamId === ws.id);
+
+  // Durable sessions from silverwood, overlaid with liveness + lock.
+  let durable: Record<string, sw.AgentSession> = {};
+  try {
+    durable = await sw.sessionLs(ws.id);
+  } catch (e: any) {
+    logError(`\x1b[38;5;141m[sessions]\x1b[0m ${ws.id}: ${e.message}`);
+  }
+  const tabs: any[] = [];
+  const claimed = new Set<string>();
+  for (const [claudeId, rec] of Object.entries(durable)) {
+    const match = runtimes.find(([k, s]) => k === claudeId || s.claudeSessionId === claudeId);
+    if (match) claimed.add(match[0]);
+    tabs.push({
+      sessionId: match ? match[0] : claudeId,
+      claudeSessionId: claudeId,
+      name: rec.name,
+      createdAt: rec.created_at,
+      kind: rec.kind,
+      connected: !!match,
+      status: match ? match[1].status : "disconnected",
+      lock: rec.lock ? { holder: rec.lock.holder, mine: rec.lock.holder === HOLDER } : null,
+    });
+  }
+  // Fresh, live PTYs not yet recorded in silverwood (pre status-hook). Surfaced by
+  // the server (its own runtime truth), so the client never invents a tab.
+  for (const [key, s] of runtimes) {
+    if (claimed.has(key)) continue;
+    tabs.push({
+      sessionId: key,
+      claudeSessionId: s.claudeSessionId,
+      name: "claude",
+      createdAt: ws.created_at,
+      kind: "claude-code",
+      connected: true,
+      status: s.status,
+      lock: null,
+    });
+  }
+
+  const live = tabs.find((t) => t.connected);
+  const status = live
+    ? live.status
     : cstate === "failed"
       ? "error"
       : cstate === "pending"
         ? "idle"
         : "disconnected";
+
   const position = sw.decodeKv<{ x: number; y: number }>(kv, "position");
   return {
     nodeId: ws.id,
     sessionId: ws.id,
-    agentId: runtime?.agentId || "claude",
-    agentName: runtime?.agentName || "Claude Code",
-    command: runtime?.command || "claude",
+    agentId: "claude",
+    agentName: "Claude Code",
+    command: "claude",
     cwd,
     createdAt: ws.created_at,
     customName: ws.name,
@@ -75,23 +123,20 @@ function buildNode(ws: sw.Workstream) {
     notes: sw.decodeKv<string>(kv, "notes"),
     ...(position ? { position } : {}),
     status,
-    isAlive: true,
-    isRestored: !runtime?.pty,
     checkoutState: cstate,
     source: ws.mode?.initial_source,
+    sessions: tabs,
   };
 }
 
-// List active workstreams as nodes; ensure a dormant runtime entry per node; prune
-// runtime entries for workstreams that no longer exist (archived/deleted).
+// List active workstreams as nodes; prune runtime PTYs for workstreams that no
+// longer exist (archived/deleted, possibly by another process). Re-reads
+// silverwood fresh every call, so the projection tracks concurrent external
+// mutations. One `session ls` per workstream — fine at personal scale.
 async function hydrateNodes() {
   const wss = await sw.list();
-  const alive = new Set(wss.map((w) => w.id));
-  for (const id of [...sessions.keys()]) {
-    if (!alive.has(id)) killTerminal(id);
-  }
-  for (const ws of wss) ensureDormant(ws.id, sw.checkoutLocation(ws) || "");
-  return wss.map(buildNode);
+  pruneWorkstreams(new Set(wss.map((w) => w.id)));
+  return Promise.all(wss.map(buildNode));
 }
 
 apiRoutes.get("/state", async (c) => {
@@ -113,9 +158,9 @@ apiRoutes.get("/sessions", async (c) => {
 });
 
 apiRoutes.get("/sessions/:sessionId/status", (c) => {
-  const s = sessions.get(c.req.param("sessionId"));
-  if (!s) return c.json({ status: "disconnected", isRestored: true });
-  return c.json({ status: s.status, isRestored: s.isRestored });
+  const r = resolveRuntime(c.req.param("sessionId"));
+  if (!r) return c.json({ status: "disconnected" });
+  return c.json({ status: r[1].status });
 });
 
 // Create a node = create a silverwood workstream (clones its checkout), then spawn
@@ -138,16 +183,10 @@ apiRoutes.post("/sessions", async (c) => {
   if (position) await sw.setKv(ws.id, "position", position);
 
   const cwd = sw.checkoutLocation(ws) || "";
+  let initialSessionId: string | undefined;
   if (sw.checkoutState(ws) === "ready" && cwd) {
-    spawnTerminal({
-      workstreamId: ws.id,
-      cwd,
-      agentId: "claude",
-      agentName: "Claude Code",
-      command: "claude",
-    });
-  } else {
-    ensureDormant(ws.id, cwd);
+    initialSessionId = randomUUID();
+    spawnTerminal({ sessionKey: initialSessionId, workstreamId: ws.id, cwd, command: "claude" });
   }
 
   return c.json({
@@ -155,15 +194,26 @@ apiRoutes.post("/sessions", async (c) => {
     nodeId: ws.id,
     cwd,
     checkoutState: sw.checkoutState(ws),
+    initialSessionId,
   });
 });
 
-// Spawn (or respawn) a node's terminal — the "Spawn Fresh" action.
-apiRoutes.post("/sessions/:sessionId/restart", async (c) => {
-  const id = c.req.param("sessionId");
+// Connect (resume) an existing session: acquire its advisory lock, then spawn a
+// `claude --resume <id>` PTY in the checkout. `force` steals a lock held elsewhere.
+apiRoutes.post("/sessions/:wsId/sessions/connect", async (c) => {
+  const wsId = c.req.param("wsId");
+  const { sessionId, force } = await c.req.json();
+  if (!sessionId) return c.json({ error: "sessionId is required" }, 400);
+
+  // Already live in this process? Just report it.
+  const existing = resolveRuntime(sessionId);
+  if (existing && existing[1].workstreamId === wsId) {
+    return c.json({ sessionId: existing[0], connected: true });
+  }
+
   let ws: sw.Workstream;
   try {
-    ws = await sw.get(id);
+    ws = await sw.get(wsId);
   } catch (e: any) {
     return c.json({ error: e.message }, 404);
   }
@@ -171,15 +221,58 @@ apiRoutes.post("/sessions/:sessionId/restart", async (c) => {
   if (!cwd || sw.checkoutState(ws) !== "ready") {
     return c.json({ error: "checkout not ready" }, 400);
   }
-  const existing = sessions.get(id);
-  spawnTerminal({
-    workstreamId: id,
+
+  // Acquire the advisory lock. A contention failure → 409 so the UI can offer
+  // Force; any other silverwood error is logged and ignored (the lock is advisory,
+  // so it must never block a connect on its own).
+  let holdsLock = false;
+  try {
+    await sw.sessionLock(wsId, sessionId, HOLDER, !!force);
+    holdsLock = true;
+  } catch (e: any) {
+    const m = /is locked by (.+)$/.exec((e.message || "").trim());
+    if (m) return c.json({ error: e.message, locked: true, holder: m[1] }, 409);
+    log(`\x1b[38;5;141m[lock]\x1b[0m acquire ${sessionId}: ${e.message}`);
+  }
+
+  const session = spawnTerminal({
+    sessionKey: sessionId,
+    workstreamId: wsId,
     cwd,
-    agentId: existing?.agentId || "claude",
-    agentName: existing?.agentName || "Claude Code",
-    command: existing?.command || "claude",
+    command: `claude --resume ${sessionId}`,
+    claudeSessionId: sessionId,
+    resumed: true,
   });
-  log(`\x1b[38;5;141m[session]\x1b[0m spawned ${id}`);
+  session.holdsLock = holdsLock;
+  log(`\x1b[38;5;141m[session]\x1b[0m connected ${sessionId}`);
+  return c.json({ sessionId, connected: true });
+});
+
+// Add a fresh session tab: spawn a new `claude` PTY under a provisional id. Its
+// durable silverwood session + lock are recorded later by the status hook.
+apiRoutes.post("/sessions/:wsId/sessions", async (c) => {
+  const wsId = c.req.param("wsId");
+  let ws: sw.Workstream;
+  try {
+    ws = await sw.get(wsId);
+  } catch (e: any) {
+    return c.json({ error: e.message }, 404);
+  }
+  const cwd = sw.checkoutLocation(ws) || "";
+  if (!cwd || sw.checkoutState(ws) !== "ready") {
+    return c.json({ error: "checkout not ready" }, 400);
+  }
+  const sessionId = randomUUID();
+  spawnTerminal({ sessionKey: sessionId, workstreamId: wsId, cwd, command: "claude" });
+  log(`\x1b[38;5;141m[session]\x1b[0m spawned fresh ${sessionId}`);
+  return c.json({ sessionId, connected: true });
+});
+
+// Disconnect a session: kill its live PTY (releasing the lock). The durable
+// silverwood session is untouched, so the tab remains (disconnected).
+apiRoutes.post("/sessions/:wsId/sessions/:sessionId/disconnect", (c) => {
+  const r = resolveRuntime(c.req.param("sessionId"));
+  if (r) killTerminal(r[0]);
   return c.json({ success: true });
 });
 
@@ -207,10 +300,13 @@ apiRoutes.patch("/sessions/:sessionId", async (c) => {
   return c.json({ success: true });
 });
 
-// Delete a node = kill its terminal + archive the workstream (tombstone).
+// Delete a node = kill all its terminals (releasing their locks) + archive the
+// workstream (tombstone).
 apiRoutes.delete("/sessions/:sessionId", async (c) => {
   const id = c.req.param("sessionId");
-  killTerminal(id);
+  for (const [key, s] of [...sessions]) {
+    if (s.workstreamId === id) killTerminal(key);
+  }
   try {
     await sw.archive(id);
   } catch (e: any) {
@@ -251,12 +347,18 @@ apiRoutes.post("/status-update", async (c) => {
   if (claudeSessionId && !session.claudeSessionId) {
     session.claudeSessionId = claudeSessionId;
   }
-  // Record the agent session in silverwood once (fire-and-forget).
+  // Record the agent session in silverwood once, under its WORKSTREAM id (the
+  // registry key is a provisional uuid), then acquire its advisory lock so other
+  // clients see it as in-use. Fire-and-forget.
   if (claudeSessionId && !session.silverwoodSessionRecorded) {
     session.silverwoodSessionRecorded = true;
-    sw.sessionCreate(foundId, claudeSessionId, session.agentName || "claude").catch((e) =>
-      log(`\x1b[38;5;141m[session-register]\x1b[0m ${e.message}`),
-    );
+    const s = session;
+    sw.sessionCreate(s.workstreamId, claudeSessionId, "claude")
+      .then(() => sw.sessionLock(s.workstreamId, claudeSessionId, HOLDER))
+      .then(() => {
+        s.holdsLock = true;
+      })
+      .catch((e) => log(`\x1b[38;5;141m[session-register]\x1b[0m ${e.message}`));
   }
 
   // Permission detection: a PreToolUse with no matching PostToolUse within 2.5s
@@ -276,7 +378,6 @@ apiRoutes.post("/status-update", async (c) => {
               JSON.stringify({
                 type: "status",
                 status: "waiting_input",
-                isRestored: session!.isRestored,
                 currentTool: session!.currentTool,
                 hookEvent: "permission_timeout",
               }),
@@ -314,7 +415,6 @@ apiRoutes.post("/status-update", async (c) => {
         JSON.stringify({
           type: "status",
           status: session.status,
-          isRestored: session.isRestored,
           currentTool: session.currentTool,
           hookEvent,
         }),
diff --git a/experimental/papyrus/server/services/sessionManager.ts b/experimental/papyrus/server/services/sessionManager.ts
index f723401..362e1b2 100644
--- a/experimental/papyrus/server/services/sessionManager.ts
+++ b/experimental/papyrus/server/services/sessionManager.ts
@@ -1,13 +1,21 @@
 import { spawn as spawnPty } from "bun-pty";
 import { existsSync } from "fs";
 import { join } from "path";
-import { homedir } from "os";
+import { homedir, hostname } from "os";
+import { randomUUID } from "crypto";
 import { PORT, HOST } from "../config";
 import type { Session } from "../types";
+import * as sw from "./silverwood";
 
 const QUIET = !!process.env.OPENUI_QUIET;
 const log = QUIET ? () => {} : console.log.bind(console);
 
+// This papyrus instance's advisory-lock holder token, fixed for the server's
+// lifetime. The random suffix means a restarted papyrus (which may reuse a pid)
+// never mistakes a lock left by a previous run for its own — it would force-steal
+// deliberately instead.
+export const HOLDER = `papyrus:${hostname()}:${process.pid}:${randomUUID().slice(0, 8)}`;
+
 // Locate the Claude Code plugin dir (adds the status hooks that drive node
 // state). Installed under ~/.openui/claude-code-plugin, or vendored in-repo.
 function getPluginDir(): string | null {
@@ -38,50 +46,35 @@ export function injectPluginDir(command: string, agentId: string): string {
 
 const MAX_BUFFER_SIZE = 1000;
 
-// In-memory runtime state, keyed by silverwood workstream id. Purely ephemeral —
-// PTYs, connected WebSocket clients, live status, and terminal scrollback all live
-// here and are allowed to vanish on restart. All durable state is in silverwood.
+// The in-memory live-PTY registry, keyed by runtime session key. An entry exists
+// iff a PTY is live. Purely ephemeral — PTYs, WebSocket clients, scrollback, and
+// live status all live here and vanish on restart. All durable state is in
+// silverwood; nothing here is cached from it.
 export const sessions = new Map<string, Session>();
 
-/// Ensure a (dormant) runtime entry exists for a workstream, so the WebSocket and
-/// status endpoints can resolve it before its terminal is spawned. Records the
-/// checkout `cwd` so a later spawn runs in the right directory.
-export function ensureDormant(workstreamId: string, cwd = ""): Session {
-  let session = sessions.get(workstreamId);
-  if (!session) {
-    session = {
-      pty: null,
-      agentId: "claude",
-      agentName: "Claude Code",
-      command: "claude",
-      cwd,
-      createdAt: new Date().toISOString(),
-      clients: new Set(),
-      outputBuffer: [],
-      status: "disconnected",
-      lastOutputTime: 0,
-      lastInputTime: 0,
-      recentOutputSize: 0,
-      isRestored: true,
-    };
-    sessions.set(workstreamId, session);
-  } else if (cwd && !session.cwd) {
-    session.cwd = cwd;
+// Release the advisory lock this instance holds for a session, if any
+// (best-effort; a crash skips it and the lock is recovered via a force-steal).
+function releaseLock(session: Session): void {
+  if (session.holdsLock && session.claudeSessionId) {
+    session.holdsLock = false;
+    sw.sessionUnlock(session.workstreamId, session.claudeSessionId, HOLDER).catch((e) =>
+      log(`\x1b[38;5;141m[lock]\x1b[0m release ${session.claudeSessionId}: ${e.message}`),
+    );
   }
-  return session;
 }
 
-/// Spawn a fresh terminal for a workstream: a bash PTY in the checkout dir that
-/// runs `command` (e.g. `claude`). Reuses/updates the runtime entry. Returns it.
+/// Spawn a terminal for a session: a bash PTY in the checkout dir that runs
+/// `command` (`claude` fresh, or `claude --resume <id>`). Registered under
+/// `sessionKey`. On process exit, releases the lock and drops the entry.
 export function spawnTerminal(params: {
+  sessionKey: string;
   workstreamId: string;
   cwd: string;
-  agentId: string;
-  agentName: string;
   command: string;
+  claudeSessionId?: string;
+  resumed?: boolean;
 }): Session {
-  const { workstreamId, cwd, agentId, agentName, command } = params;
-  const session = ensureDormant(workstreamId, cwd);
+  const { sessionKey, workstreamId, cwd, command, claudeSessionId, resumed } = params;
 
   const ptyProcess = spawnPty("/bin/bash", [], {
     name: "xterm-256color",
@@ -90,12 +83,10 @@ export function spawnTerminal(params: {
       ...process.env,
       TERM: "xterm-256color",
       // The plugin echoes this back on status hooks so we can correlate.
-      OPENUI_SESSION_ID: workstreamId,
-      // Tell the plugin's status-reporter where the server actually is. Without
-      // this it falls back to its hardcoded 6969 while the server is on 6968, so
-      // every status POST (which carries the Claude session id we record) is
-      // silently dropped. Propagating the real port fixes it regardless of which
-      // plugin copy loads (in-store vendored or a stale ~/.openui one).
+      OPENUI_SESSION_ID: sessionKey,
+      // Tell the plugin's status-reporter where the server actually is (its
+      // hardcoded fallback is a different port), so every status POST — which
+      // carries the Claude session id we record — is not silently dropped.
       OPENUI_PORT: String(PORT),
       OPENUI_HOST: HOST,
     },
@@ -103,18 +94,26 @@ export function spawnTerminal(params: {
     cols: 120,
   });
 
-  session.pty = ptyProcess;
-  session.agentId = agentId;
-  session.agentName = agentName;
-  session.command = command;
-  session.cwd = cwd;
-  session.status = "running";
-  session.isRestored = false;
-  session.outputBuffer = [];
-  session.lastOutputTime = Date.now();
+  const session: Session = {
+    pty: ptyProcess,
+    workstreamId,
+    cwd,
+    clients: new Set(),
+    outputBuffer: [],
+    status: "running",
+    lastOutputTime: Date.now(),
+    lastInputTime: 0,
+    recentOutputSize: 0,
+    claudeSessionId,
+    resumed: !!resumed,
+    // A resumed session's silverwood record + lock already exist, so the status
+    // hook must not re-record it.
+    silverwoodSessionRecorded: !!resumed,
+  };
+  sessions.set(sessionKey, session);
 
   const resetInterval = setInterval(() => {
-    if (!sessions.has(workstreamId) || !session.pty) {
+    if (sessions.get(sessionKey) !== session) {
       clearInterval(resetInterval);
       return;
     }
@@ -133,20 +132,52 @@ export function spawnTerminal(params: {
     }
   });
 
-  const finalCommand = injectPluginDir(command, agentId);
+  ptyProcess.onExit(() => {
+    clearInterval(resetInterval);
+    // Only tear down if this exact entry is still the live one for the key.
+    if (sessions.get(sessionKey) === session) {
+      releaseLock(session);
+      session.clients.clear();
+      sessions.delete(sessionKey);
+      log(`\x1b[38;5;141m[terminal]\x1b[0m exited ${sessionKey}`);
+    }
+  });
+
+  const finalCommand = injectPluginDir(command, "claude");
   setTimeout(() => ptyProcess.write(`${finalCommand}\r`), 300);
 
-  log(`\x1b[38;5;141m[terminal]\x1b[0m spawned ${workstreamId} in ${cwd}`);
+  log(`\x1b[38;5;141m[terminal]\x1b[0m spawned ${sessionKey} in ${cwd}`);
   return session;
 }
 
-/// Tear down a workstream's terminal + runtime entry. Does NOT touch silverwood.
-export function killTerminal(workstreamId: string): boolean {
-  const session = sessions.get(workstreamId);
+/// Resolve a runtime entry by its registry key, or by the claude session id it
+/// carries (a fresh PTY is keyed by a provisional id but learns its claude id).
+export function resolveRuntime(id: string): [string, Session] | undefined {
+  const direct = sessions.get(id);
+  if (direct) return [id, direct];
+  for (const [key, s] of sessions) {
+    if (s.claudeSessionId === id) return [key, s];
+  }
+  return undefined;
+}
+
+/// Tear down a session's terminal + registry entry, releasing its lock. Does NOT
+/// touch silverwood's durable session record.
+export function killTerminal(sessionKey: string): boolean {
+  const session = sessions.get(sessionKey);
   if (!session) return false;
-  if (session.pty) session.pty.kill();
+  releaseLock(session);
+  session.pty.kill();
   session.clients.clear();
-  sessions.delete(workstreamId);
-  log(`\x1b[38;5;141m[terminal]\x1b[0m killed ${workstreamId}`);
+  sessions.delete(sessionKey);
+  log(`\x1b[38;5;141m[terminal]\x1b[0m killed ${sessionKey}`);
   return true;
 }
+
+/// Kill runtime entries whose workstream no longer exists (archived/deleted
+/// elsewhere), releasing their locks — keeps the registry a projection of the forest.
+export function pruneWorkstreams(aliveWsIds: Set<string>): void {
+  for (const [key, s] of [...sessions]) {
+    if (!aliveWsIds.has(s.workstreamId)) killTerminal(key);
+  }
+}
diff --git a/experimental/papyrus/server/services/silverwood.ts b/experimental/papyrus/server/services/silverwood.ts
index bc7be77..c2d59e3 100644
--- a/experimental/papyrus/server/services/silverwood.ts
+++ b/experimental/papyrus/server/services/silverwood.ts
@@ -43,6 +43,8 @@ export interface AgentSession {
   kind: string;
   name: string;
   created_at: string;
+  // The claude-code kind's best-effort advisory lock, if currently held.
+  lock?: { holder: string; acquired_at: string };
 }
 
 /// Run `silverwood --json <args>` and parse its stdout. Async (never blocks the
@@ -140,6 +142,39 @@ export function sessionRemove(id: string, sessionId: string): Promise<void> {
   return serialize(id, () => run(["session", "rm", id, sessionId]));
 }
 
+/// Acquire the best-effort advisory lock on a session for `holder`. Rejects (the
+/// CLI exits non-zero) if held by another holder, unless `force` steals it.
+export function sessionLock(
+  id: string,
+  sessionId: string,
+  holder: string,
+  force = false,
+): Promise<void> {
+  return serialize(id, () =>
+    run(["session", "lock", id, sessionId, "--holder", holder, ...(force ? ["--force"] : [])]),
+  );
+}
+
+/// Release the advisory lock on a session (no-op if unlocked; rejects if held by
+/// a different holder without `force`).
+export function sessionUnlock(
+  id: string,
+  sessionId: string,
+  holder?: string,
+  force = false,
+): Promise<void> {
+  return serialize(id, () =>
+    run([
+      "session",
+      "unlock",
+      id,
+      sessionId,
+      ...(holder ? ["--holder", holder] : []),
+      ...(force ? ["--force"] : []),
+    ]),
+  );
+}
+
 // silverwood does read-modify-overwrite of the whole document with no file
 // locking, so two concurrent writers to the SAME workstream can lose an update.
 // Serialize every mutation per workstream id through an in-process promise chain.
diff --git a/experimental/papyrus/server/types/index.ts b/experimental/papyrus/server/types/index.ts
index 27801ed..21a2b80 100644
--- a/experimental/papyrus/server/types/index.ts
+++ b/experimental/papyrus/server/types/index.ts
@@ -9,32 +9,39 @@ export type AgentStatus =
   | "disconnected"
   | "error";
 
-// Runtime-only state for a workstream's terminal. Ephemeral: everything here is
-// rebuilt or discarded on restart. Durable state lives in silverwood.
+// A live-PTY registry entry — the ONE thing papyrus owns that silverwood cannot
+// model (a running process, its clients, scrollback, and live status). Purely
+// ephemeral: an entry exists iff a PTY is live. All durable data (session list,
+// names, lock) is re-read from silverwood on demand — never cached here. Keyed in
+// the registry by the runtime session key (the claude session id for a resumed
+// session; a provisional uuid for a fresh one until the plugin reports its id).
 export interface Session {
-  pty: IPty | null;
-  agentId: string;
-  agentName: string;
-  command: string;
+  pty: IPty;
+  // The workstream this PTY belongs to (the registry is no longer keyed by it).
+  workstreamId: string;
   cwd: string;
-  createdAt: string;
   clients: Set<ServerWebSocket<WebSocketData>>;
   outputBuffer: string[];
   status: AgentStatus;
   lastOutputTime: number;
   lastInputTime: number;
   recentOutputSize: number;
-  isRestored?: boolean;
-  // Live status reported by the Claude Code plugin's hooks.
+  // The claude session id: known up front for a resumed session, learned from the
+  // plugin hook for a fresh one. Used for reconciliation, recording, and the lock.
   claudeSessionId?: string;
+  // Spawned via `--resume` (its silverwood session + lock already exist).
+  resumed: boolean;
+  // Whether a silverwood session has been recorded for claudeSessionId already.
+  silverwoodSessionRecorded: boolean;
+  // Whether this instance currently holds the advisory lock for claudeSessionId.
+  holdsLock?: boolean;
+  // Live status reported by the Claude Code plugin's hooks.
   currentTool?: string;
   preToolTime?: number;
   permissionTimeout?: ReturnType<typeof setTimeout>;
   pluginReportedStatus?: boolean;
   lastPluginStatusTime?: number;
   lastHookEvent?: string;
-  // Whether a silverwood session has been recorded for claudeSessionId already.
-  silverwoodSessionRecorded?: boolean;
 }
 
 export interface LinearTicket {
-- 
2.54.0