create-pmos 0.17.0 → 0.18.1

package/workspace/public/pm/panel-tabs.js

@@ -146,7 +146,32 @@ export function closeTab(id) {
 /* The data layer's optional session-start hook. In fixture mode nothing is ever started; in real
  * mode the PTY is data.js's to create, and panel 4's part is only to show the tab for it. */
 let dataMod = null;
-import('./data.js').then((m) => { dataMod = m; }).catch(() => { dataMod = null; });
+/* The repaint matters: `syncPad` below cannot name a pad before this module exists, so the render
+ * that lands it is the render that first loads the PM's staged text. */
+import('./data.js').then((m) => { dataMod = m; setState({}); }).catch(() => { dataMod = null; });
+
+/**
+ * The next free `agent <n>`, counted against EVERY name the window can see — the server's live
+ * sessions, the ones started in this window, and the tabs already open — not just this page's
+ * counter.
+ *
+ * `startN` resets to 1 on every reload, and the name is what the terminal used to join on and what
+ * the tab id is built from. So after a reload the first `＋ session` proposed `agent 1`, which was
+ * already running from before the reload: the click attached to that old session instead of
+ * starting a new one, and a second click collided with its own tab id. Counting past what exists
+ * is what makes `＋ session` mean "a new one" again.
+ */
+function nextSessionName() {
+  let max = state.startN - 1;
+  const bump = (name) => {
+    const m = /^agent (\d+)$/.exec(String(name || ''));
+    if (m) max = Math.max(max, Number(m[1]));
+  };
+  for (const s of (state.sessions || [])) bump(s && s.name);
+  for (const k in (state.extraSess || {})) for (const s of (state.extraSess[k] || [])) bump(s && s.name);
+  for (const t of (state.tabs || [])) if (t && t.kind === 'term') bump(t.sess);
+  return { n: max + 1, name: 'agent ' + (max + 1) };
+}
 
 /**
  * `＋ session` (line 2087): file a new session against the selected initiative and open its tab.
@@ -156,8 +181,11 @@ import('./data.js').then((m) => { dataMod = m; }).catch(() => { dataMod = null;
 export function newSession(slug) {
   const target = slug || selSlug();
   if (!target) return;
-  const n = state.startN;
-  const sess = { name: 'agent ' + n, st: 'working', label: 'working', profile: state.newSessProfile };
+  const { n, name } = nextSessionName();
+  /* `spawn` is carried on the session and thence onto the tab: it is an INSTRUCTION to start a PTY,
+   * and it is the only thing that authorises one. Without it the terminal resolves by name, which
+   * is a question about what already exists, not a request for something new. */
+  const sess = { name, st: 'working', label: 'working', profile: state.newSessProfile, spawn: true };
   setState((s) => ({
     startN: n + 1,
     extraSess: { ...s.extraSess, [target]: [...(s.extraSess[target] || []), sess] },
@@ -204,13 +232,118 @@ const panesRow = el('div', { style: 'flex:1;display:flex;min-height:0' });
  * One textarea, created once. Its text is written back as a CHILD TEXT NODE as well as a value,
  * because that is what the prototype's runtime does and the comparator reads text nodes — but only
  * when the two differ, so a repaint mid-sentence never moves the PM's caret.
+ *
+ * ── ONE PAD PER SESSION ─────────────────────────────────────────────────────────────────────
+ * The pad stages the next thing to type into a PARTICULAR agent, so it belongs to that agent's
+ * session. The four-panel port shipped it as one in-memory string for the whole page, which meant
+ * every terminal — in every repository, in every window — showed and overwrote the same buffer.
+ *
+ * The store is `state.scratchPads`, keyed by:
+ *   `sess:<server session id>` — a terminal tab bound to a live PTY. The id is the SERVER's, so two
+ *                                sessions both called `agent 1` in two repositories are two pads.
+ *   `ws:<workspace id>`        — everything else (a doc, a task, nothing open): the repository pad.
+ * That is exactly the key space `/api/scratchpad` already stores under — the endpoint has been
+ * per-session all along, and it is the client half that went missing. `state.scratchText` remains
+ * the text ON SCREEN, so the copy button, `⇥ send to terminal` and the fixture render are unchanged.
+ *
+ * FIXTURE MODE IS UNTOUCHED: no key, no fetch, one pad, the prototype's own placeholder. The offline
+ * demo path must make no network call, and the comparator must see the design's string.
  */
+const SCRATCH_PLACEHOLDER = FIXTURE
+  ? 'scratchpad — survives tab switches, dies with the page'
+  : 'scratchpad — one pad per session, saved on this machine';
+
 const scratchTa = el('textarea', {
-  placeholder: 'scratchpad — survives tab switches, dies with the page',
+  placeholder: SCRATCH_PLACEHOLDER,
   style: 'height:96px;background:oklch(0.11 0.004 228.8);color:#c4ccce;padding:10px 14px;font-family:var(--mono);font-size:12px',
-  onInput: (e) => setState({ scratchText: e.target.value }),
+  onInput: (e) => onScratchInput(e.target.value),
 });
 
+/* ── pad identity, loading and autosave ─────────────────────────────────────────────────────── */
+
+const padLoading = new Set();      // keys with a read in flight — one read per key, ever
+let padTimer = null;
+let padPending = null;             // {key, text} not yet written
+
+/** The pad the ACTIVE tab stages against, or null when it cannot be named yet. */
+function padKey() {
+  if (FIXTURE) return null;
+  const act = activeTab();
+  if (act && act.kind === 'term') {
+    const id = (termMod && typeof termMod.sessionIdOf === 'function')
+      ? termMod.sessionIdOf(act) : (act.sessionId || null);
+    // A terminal whose session has not resolved yet has no pad of its own YET. Null holds the
+    // drawer on whatever it was showing rather than flashing an empty pad and then SAVING it over
+    // the real one the moment the session lands.
+    return id ? 'sess:' + id : null;
+  }
+  return state.wsId ? 'ws:' + state.wsId : null;
+}
+
+/** Write the pending pad now. Called before leaving a pad, and when the page goes away. */
+function flushPad() {
+  if (padTimer) { clearTimeout(padTimer); padTimer = null; }
+  if (!padPending) return;
+  const { key, text } = padPending;
+  padPending = null;
+  if (dataMod && typeof dataMod.saveScratchpad === 'function') {
+    try { dataMod.saveScratchpad(key, text); } catch { /* the text stays in state either way */ }
+  }
+}
+
+function schedulePadSave(key, text) {
+  padPending = { key, text };
+  if (padTimer) clearTimeout(padTimer);
+  padTimer = setTimeout(flushPad, 500);      // one write per pause, not one per keystroke
+}
+
+function onScratchInput(text) {
+  if (FIXTURE) { setState({ scratchText: text }); return; }
+  const key = state.scratchKey;
+  setState((s) => ({
+    scratchText: text,
+    scratchPads: key ? { ...s.scratchPads, [key]: text } : s.scratchPads,
+  }));
+  if (key) schedulePadSave(key, text);
+}
+
+/**
+ * Bring the drawer onto the pad the active tab belongs to, reading it from the server the first
+ * time that pad is seen. Called at the top of every render; a no-op unless the pad CHANGED.
+ */
+function syncPad() {
+  if (FIXTURE || !dataMod) return;           // no data layer yet — retried on the next render
+  const key = padKey();
+  if (!key || key === state.scratchKey) return;
+  flushPad();                                // the pad being left is written before it is left
+  if (Object.prototype.hasOwnProperty.call(state.scratchPads, key)) {
+    setState({ scratchKey: key, scratchText: state.scratchPads[key] });
+    return;
+  }
+  setState({ scratchKey: key, scratchText: '' });
+  if (padLoading.has(key)) return;
+  padLoading.add(key);
+  const landed = (text) => {
+    padLoading.delete(key);
+    setState((s) => ({
+      scratchPads: { ...s.scratchPads, [key]: text },
+      // …and onto the screen only if this is still the pad on screen. A PM who switched tabs while
+      // the read was in flight must not have the arriving text land in the pad they moved to.
+      ...(s.scratchKey === key ? { scratchText: text } : {}),
+    }));
+  };
+  try { dataMod.loadScratchpad(key).then(landed, () => landed('')); }
+  catch { padLoading.delete(key); }
+}
+
+/* A pad edited in the last half-second is still worth keeping when the tab is closed or the machine
+ * sleeps. `pagehide` fires where `beforeunload` is unreliable (bfcache, mobile), and both are cheap. */
+if (typeof window !== 'undefined' && !FIXTURE) {
+  window.addEventListener('pagehide', flushPad);
+  window.addEventListener('beforeunload', flushPad);
+  document.addEventListener('visibilitychange', () => { if (document.hidden) flushPad(); });
+}
+
 const scratchCopyLabel = iv('⧉ copy');
 const scratchCopyBtn = el('button', {
   onClick: () => {
@@ -396,7 +529,13 @@ function tabNode(t, act, splitTab) {
   const bc = selected ? FX.TAB_COLORS.activeBorder : FX.TAB_COLORS.idleBorder;
   const color = act && act.id === t.id ? FX.TAB_COLORS.activeText : FX.TAB_COLORS.idleText;
   const dotColor = FX.TAB_COLORS.dot[t.kind] || FX.TAB_COLORS.dot.doc;
-  const meta = t.kind === 'term' ? 'session' : (t.kind === 'task' ? 'task' : t.role);
+  /* A terminal's sub-line names the SESSION IT IS ON, not the word "session". After a reload the PM
+   * could not tell which session a re-opened tab had landed on, and the answer was on screen
+   * nowhere; the server's id is the one identifier that does not repeat across repositories. The
+   * fixture render keeps the design's literal — the comparator reads this text node. */
+  const meta = t.kind === 'term'
+    ? ((!FIXTURE && t.sessionId) ? 'session ' + t.sessionId : 'session')
+    : (t.kind === 'task' ? 'task' : t.role);
 
   return el('div', {
     style: 'flex:none;display:flex;align-items:center;gap:8px;padding:0 10px;background:' + bg
@@ -433,6 +572,8 @@ function tabNode(t, act, splitTab) {
  * bar. The panes row renders even when nothing is open, exactly as the design does.
  */
 export function renderTabs(host) {
+  // Which pad the drawer is on is decided from the active tab, before anything is painted from it.
+  syncPad();
   const visTabs = visibleTabs();
   const act = visTabs.find((t) => t.id === state.active) || null;
   const splitTab = state.splitId

package/workspace/public/pm/state.js

@@ -41,15 +41,37 @@ function initial() {
     col0: true, col1: true, col2: true, scratchOpen: false, scratchText: '', copied: false,
     flowsMap: null, schedList: null, agentList: null, memory: null,
     savedDocs: {}, scratchCopied: false,
+    /* The scratchpad is ONE PAD PER SESSION, not one per page (see panel-tabs.js). `scratchPads`
+     * holds every pad this window has loaded, keyed by the pad key the panel derives — `sess:<id>`
+     * for a terminal bound to a PTY, `ws:<id>` for the repository pad a non-terminal tab stages
+     * against. `scratchText` remains the text ON SCREEN, so every existing reader (the copy button,
+     * ⇥ send to terminal, the fixture render) is unchanged. `scratchKey` is which pad that is. */
+    scratchPads: {}, scratchKey: null,
   };
 }
 
 /* ── persistence ──────────────────────────────────────────────────────────────────────────────
- * Only the PM's *arrangement* is persisted — never content, never tabs, never a live session.
- * Each key carries its own validator. A stored value that fails its validator is DROPPED and the
- * rest of the record is still applied: "layout amnesia" in the PRD's failure-mode list means a
- * stale record from an older build throwing, or silently wiping a layout the PM is working in.
- * An unknown key is simply not read, so an older or newer schema costs nothing.
+ * The PM's *arrangement*, and — since the reload defect — WHICH VIEWS WERE OPEN. Never content,
+ * never a pad's text, never a live PTY: a tab is a view of a session the server owns, and what is
+ * stored here is the identity of the view, not the thing it looks at.
+ *
+ * Each key carries its own validator, and optionally a `pack` that decides what is WRITTEN. A
+ * stored value that fails its validator is DROPPED and the rest of the record is still applied:
+ * "layout amnesia" in the PRD's failure-mode list means a stale record from an older build
+ * throwing, or silently wiping a layout the PM is working in. An unknown key is simply not read,
+ * so an older or newer schema costs nothing.
+ *
+ * ── Why `tabs` is here, and why it was not ──────────────────────────────────────────────────
+ * It read "never tabs" because a tab was thought to be a live thing. It is not: the PTY lives in
+ * the server and survives both detach and a server restart (R7), so a window that forgot its tabs
+ * was not protecting anything — it was throwing away the only record of which sessions the PM had
+ * open. The PM then had to re-find them by hand, one click at a time, with no way to tell which
+ * session a re-opened tab had landed on. Restoring the views is what makes the surviving sessions
+ * visible again on reload.
+ *
+ * The stored tab is PACKED, not the live record: a whitelist of scalar fields, capped at 40 tabs.
+ * A doc tab's edited buffer, a task's derived prose, and anything a future field might carry stay
+ * out of localStorage by construction rather than by remembering to exclude them.
  */
 const isBool = (v) => typeof v === 'boolean';
 const isSlug = (v) => v === null || typeof v === 'string';
@@ -57,6 +79,28 @@ const isFlagMap = (v) =>
   !!v && typeof v === 'object' && !Array.isArray(v) &&
   Object.keys(v).every((k) => typeof k === 'string' && typeof v[k] === 'boolean');
 
+/* The only tab fields that are written. `sessionId` is the load-bearing one: it is the SERVER's own
+ * id, so a restored terminal re-attaches to exactly the PTY it was showing rather than re-running
+ * the name join — which is what made a reloaded tab land on a session the PM could not identify. */
+const TAB_FIELDS = ['id', 'kind', 'title', 'slug', 'repo', 'sess', 'sessionId', 'state', 'profile',
+  'path', 'role', 'phase', 'status'];
+const MAX_TABS = 40;
+
+function packTab(t) {
+  if (!t || typeof t !== 'object' || typeof t.id !== 'string' || typeof t.kind !== 'string') return null;
+  const out = {};
+  for (const k of TAB_FIELDS) {
+    const v = t[k];
+    if (v === null || typeof v === 'string' || typeof v === 'number' || typeof v === 'boolean') out[k] = v;
+  }
+  return out;
+}
+
+const isTabList = (v) =>
+  Array.isArray(v) && v.length <= MAX_TABS &&
+  v.every((t) => t && typeof t === 'object' && !Array.isArray(t)
+    && typeof t.id === 'string' && typeof t.kind === 'string');
+
 const PERSIST = {
   theme: (v) => v === 'dark' || v === 'light',
   col0: isBool, col1: isBool, col2: isBool,
@@ -65,6 +109,15 @@ const PERSIST = {
   sel: isSlug,
   collapsedGroups: isFlagMap,
   collapsedPhases: isFlagMap,
+  tabs: isTabList,
+  active: isSlug,
+  splitId: isSlug,
+  scratchOpen: isBool,
+};
+
+/** What is WRITTEN for a key, when it is not the live value verbatim. */
+const PACK = {
+  tabs: (v) => (Array.isArray(v) ? v.slice(0, MAX_TABS).map(packTab).filter(Boolean) : []),
 };
 
 /** The exact set of keys written to localStorage, in write order. */
@@ -84,13 +137,19 @@ function restore(target) {
     try { ok = PERSIST[k](saved[k]); } catch { ok = false; }
     if (ok) target[k] = saved[k];
   }
+  /* `active` and `splitId` name tabs. A record whose tab list was dropped (or that names a tab the
+   * list no longer holds) must not restore a pointer into nothing — panel 4 would render an empty
+   * pane and the PM would see a window with no tab selected and no way to guess why. */
+  const ids = new Set((target.tabs || []).map((t) => t.id));
+  if (!ids.has(target.active)) target.active = target.tabs.length ? target.tabs[target.tabs.length - 1].id : null;
+  if (!ids.has(target.splitId)) target.splitId = null;
   return target;
 }
 
 function persist() {
   if (FIXTURE) return;
   const out = {};
-  for (const k of persistKeys) out[k] = state[k];
+  for (const k of persistKeys) out[k] = PACK[k] ? PACK[k](state[k]) : state[k];
   try { localStorage.setItem(STORE_KEY, JSON.stringify(out)); } catch { /* quota / private mode */ }
 }
 

package/workspace/public/pm/tab-term.js

@@ -149,6 +149,7 @@ function connect() {
     for (const rec of panes.values()) {
       if (rec.kind !== 'real') continue;
       rec.attachedId = null;
+      rec.sentCols = null; rec.sentRows = null;   // the next connection has stated no grid yet
       note(rec, 'pmos: connection to the workspace server lost — retrying');
     }
     clearTimeout(SOCK.timer);
@@ -181,6 +182,17 @@ function handle(m) {
     rec.noted = null;
     try { rec.term.reset(); } catch { /* a disposed terminal */ }
     if (m.buf) { try { rec.term.write(m.buf); } catch { /* ignore */ } }
+    /* THE PTY DOES NOT KNOW HOW WIDE THIS BROWSER IS. `attached` carries the SERVER's cols/rows —
+     * 80×24 for a session nobody ever resized — and the server never adopts the client's grid on
+     * attach. The only thing that ever told it was xterm's `onResize`, which fires when a fit
+     * CHANGES the grid; the first fit runs while the socket is still connecting, so `sessionId` was
+     * null and the message was dropped, and every later fit measured the same box and changed
+     * nothing, so it never fired again. Result: a 200-column window rendering a shell that believes
+     * it has 80, wrapping a third of the way across — "the terminal only shows a small portion".
+     * The grid is therefore PUSHED here, unconditionally, the moment there is a session to push it
+     * to. `sent*` is cleared first so a re-attach after a reconnect re-states it. */
+    rec.sentCols = null; rec.sentRows = null;
+    syncSize(rec);
     refitVisible();
     return;
   }
@@ -199,6 +211,8 @@ function handle(m) {
     const rec = panes.get(id);
     if (!rec) { send({ t: 'detach', id: m.id }); return; }   // the tab closed while we waited
     rec.sessionId = m.id;
+    rec.sentCols = null; rec.sentRows = null;
+    rememberSession(rec.tab, m.id);
     attach(rec);
     return;
   }
@@ -218,22 +232,38 @@ const recFor = (sessionId) => {
 };
 
 /* ── binding a tab to a real session ───────────────────────────────────────────────────────────
- * The tab knows the initiative slug and the session NAME (`term:<slug>:<name>` is its id); the
- * server knows session ids. The join is by name within the tab's workspace, which is the same join
- * the sidebar has always made — a session's name is what the PM sees and what they named it.
- * `sessionId` set on the tab by the data layer wins, when there is one.
+ * `sessionId` on the tab is the ONLY exact join, and it is the one that is used whenever it exists:
+ * it is the server's own id, the data layer puts it on every tab opened from a listed session, and
+ * `rememberSession` writes it back (and so into localStorage) the first time a tab resolves. The
+ * name join below is the fallback for a tab that predates all of that.
+ *
+ * THE NAME JOIN IS SCOPED TO THE TAB'S OWN WORKSPACE, and no longer falls back to "a session with
+ * this name anywhere". Session names are not unique across repositories — every `＋ session` in
+ * every repo produces `agent 1` — so the unscoped fallback quietly attached a tab in one repository
+ * to a PTY running in another, and the PM was shown another repo's shell under their own repo's
+ * initiative. A name that resolves nowhere in this workspace is now reported as not found, which is
+ * the true answer.
  */
 function resolveSessionId(tab) {
-  if (tab.sessionId) return tab.sessionId;
   const pool = SOCK.sessions.length ? SOCK.sessions
     : (Array.isArray(state.sessions) ? state.sessions : []);
+  if (tab.sessionId) {
+    // A restored tab names a session from a previous run of this window — or of this SERVER. Trust
+    // it while nothing is known (the socket has not said `hello` yet), but once there is a list,
+    // an id that is not in it is a session that no longer exists: fall through rather than
+    // `attach`ing to it, which the server answers with silence and the PM reads as a dead pane.
+    if (!pool.length || pool.some((s) => s && s.id === tab.sessionId)) return tab.sessionId;
+  }
+  if (tab.spawn) return null;                 // a `＋ session` tab must START one, never adopt one
   const name = tab.sess;
   if (!name) return null;
   const byId = pool.find((s) => s && s.id === name);
   if (byId) return byId.id;
-  const ws = workspaceId();
+  const ws = wsForTab(tab);
   const inWs = pool.find((s) => s && s.name === name && (!ws || s.ws === ws));
   if (inWs) return inWs.id;
+  // No cross-workspace fallback. See the note above: it is how a repository showed another's shell.
+  if (ws) return null;
   const anywhere = pool.find((s) => s && s.name === name);
   return anywhere ? anywhere.id : null;
 }
@@ -254,40 +284,95 @@ function workspaceId() {
 }
 
 /**
- * Was this session started in THIS window (the `＋ session` path)? Only then may a terminal spawn a
- * PTY on its own: a tab opened against a session the board listed must attach to that session or
- * say it is gone — silently starting a second shell with the same name would be a lie about what
- * the PM is looking at.
+ * The workspace THIS TAB belongs to — which is not always the selected one. Every open terminal is
+ * kept live, including the ones belonging to a repository the PM is not currently looking at (see
+ * panel-tabs.js `keepSessionsLive`), so scoping a parked tab's name join by the SELECTED repository
+ * would scope it by the wrong repo entirely. `state.productWs` is the data layer's product-name →
+ * workspace-id map; a tab whose repository is not in it falls back to the selected workspace, which
+ * is right for the tab on screen and is all a fixture render has.
+ */
+function wsForTab(tab) {
+  const map = state.productWs;
+  if (tab && tab.repo && map && typeof map === 'object' && map[tab.repo]) return map[tab.repo];
+  return workspaceId();
+}
+
+/**
+ * Does this tab carry an instruction to START a session? Only then may a terminal spawn a PTY on
+ * its own: a tab opened against a session the board listed must attach to that session or say it is
+ * gone — silently starting a second shell with the same name would be a lie about what the PM is
+ * looking at.
+ *
+ * The flag is set by `＋ session` and travels ON THE TAB. It used to be inferred by looking the
+ * tab's session NAME up in `state.extraSess`, which is a different question wearing the same
+ * clothes: after a reload `extraSess` is empty and `startN` is back at 1, so a fresh `＋ session`
+ * produced the name `agent 1`, the name join found the `agent 1` still running from before the
+ * reload, and the click ATTACHED to an old session instead of starting a new one. The PM asked for
+ * a session and got someone else's.
  */
-function startedHere(tab) {
+function wantsSpawn(tab) {
+  if (tab && tab.spawn) return true;
   const list = (state.extraSess || {})[tab.slug];
   return Array.isArray(list) && list.some((s) => s && s.name === tab.sess);
 }
 
+/**
+ * Record the session a tab actually landed on, on the tab record itself — so it is written to
+ * localStorage and a reload re-attaches to exactly this PTY rather than re-running the name join.
+ * "I don't know which session it has reloaded" is that join being re-run against a list that has
+ * moved on; an id does not have that failure mode.
+ */
+function rememberSession(tab, sessionId) {
+  if (!tab || !sessionId) return;
+  // The guard is checked BEFORE the mutation, and on the tab record itself. `rec.tab` is very often
+  // the same object that sits in `state.tabs`, so mutating first and then comparing would always
+  // find them equal and the repaint that shows the id on the tab would never be scheduled.
+  if (tab.sessionId === sessionId && tab.spawn === false) return;
+  tab.sessionId = sessionId;
+  tab.spawn = false;
+  setState((s) => {
+    const i = (s.tabs || []).findIndex((t) => t.id === tab.id);
+    if (i < 0) return null;
+    const next = [...s.tabs];
+    next[i] = { ...next[i], sessionId, spawn: false };
+    return { tabs: next };
+  });
+}
+
 function bind(rec) {
   if (rec.kind !== 'real' || !rec.term) return;
   const id = resolveSessionId(rec.tab);
   if (id) {
-    if (rec.sessionId !== id) { rec.sessionId = id; rec.attachedId = null; }
+    if (rec.sessionId !== id) {
+      rec.sessionId = id; rec.attachedId = null; rec.sentCols = null; rec.sentRows = null;
+    }
+    rememberSession(rec.tab, id);
     attach(rec);
     return;
   }
   if (!SOCK.open) { note(rec, 'pmos: connecting to the workspace server…'); return; }
   if (SOCK.spawning.get(rec.tab.id)) return;
-  if (startedHere(rec.tab)) {
+  if (wantsSpawn(rec.tab)) {
     // agent 'shell' deliberately: PMOS cannot know which agent CLI the PM meant from a tab alone,
     // and falling back from an agent to a shell after the fact would be the dishonest version.
     SOCK.spawning.set(rec.tab.id, true);
     SOCK.spawnQueue.push(rec.tab.id);
     note(rec, 'pmos: starting a session…', true);
-    const ok = send({ t: 'new', name: rec.tab.sess, agent: 'shell', ws: workspaceId() });
+    const ok = send({ t: 'new', name: rec.tab.sess, agent: 'shell', ws: wsForTab(rec.tab) });
     if (!ok) {
       SOCK.spawning.delete(rec.tab.id);
       SOCK.spawnQueue = SOCK.spawnQueue.filter((x) => x !== rec.tab.id);
     }
     return;
   }
-  note(rec, 'pmos: no live session named "' + rec.tab.sess + '" — nothing was attached');
+  /* Say WHICH session was looked for and why it could not be found. A tab restored from a previous
+   * run names an id; one opened from the board names a name. Both are worth printing — "nothing was
+   * attached" without the identity is exactly the report that left the PM unable to tell which
+   * session a reloaded tab had landed on. */
+  note(rec, rec.tab.sessionId
+    ? 'pmos: session ' + rec.tab.sessionId + ' ("' + (rec.tab.sess || '?')
+      + '") is no longer running — nothing was attached'
+    : 'pmos: no live session named "' + rec.tab.sess + '" in this repository — nothing was attached');
 }
 
 function attach(rec) {
@@ -296,6 +381,24 @@ function attach(rec) {
   if (send({ t: 'attach', id: rec.sessionId })) SOCK.attached.add(rec.sessionId);
 }
 
+/**
+ * Tell the PTY the grid this browser is actually rendering. Sent whenever the pane is attached and
+ * the terminal's cols/rows differ from what this connection last stated — which covers the attach
+ * itself, every refit that moves the grid, and a reconnect (where `sent*` is cleared).
+ *
+ * Idempotent by design: `sent*` makes a re-render cost nothing, and the guard is on what was SENT
+ * rather than on what xterm reports, because the server holds the authoritative copy and a resize
+ * this connection never sent is a resize the shell never heard.
+ */
+function syncSize(rec) {
+  if (!rec || rec.kind !== 'real' || !rec.term) return;
+  if (!rec.sessionId || rec.attachedId !== rec.sessionId) return;
+  const cols = rec.term.cols, rows = rec.term.rows;
+  if (!cols || !rows) return;
+  if (rec.sentCols === cols && rec.sentRows === rows) return;
+  if (send({ t: 'resize', id: rec.sessionId, cols, rows })) { rec.sentCols = cols; rec.sentRows = rows; }
+}
+
 /** Write a status line into the terminal itself — once per distinct message, dimmed. */
 function note(rec, line, force) {
   if (!rec.term) return;
@@ -321,6 +424,10 @@ export function refitVisible() {
       if (!rec.host.isConnected) continue;
       if (!rec.host.offsetWidth || !rec.host.offsetHeight) continue;
       try { rec.fit.fit(); } catch { /* a terminal mid-teardown */ }
+      // …and state the resulting grid to the PTY. `fit()` only fires xterm's `onResize` when the
+      // grid MOVES, so a pane that was measured before it had a session would otherwise never tell
+      // the shell how wide it is. See the `attached` handler.
+      syncSize(rec);
     }
   };
   if (typeof requestAnimationFrame === 'function') requestAnimationFrame(run);
@@ -459,9 +566,7 @@ function buildReal(tab) {
     kind: 'real', tab, host, term, fit, sessionId: null, attachedId: null, noted: null, ro: null,
   };
   term.onData((d) => { if (rec.sessionId) send({ t: 'input', id: rec.sessionId, data: d }); });
-  term.onResize(({ cols, rows }) => {
-    if (rec.sessionId) send({ t: 'resize', id: rec.sessionId, cols, rows });
-  });
+  term.onResize(() => syncSize(rec));
   if (typeof ResizeObserver === 'function') {
     rec.ro = new ResizeObserver(() => refitVisible());
     try { rec.ro.observe(host); } catch { /* ignore */ }
@@ -534,6 +639,17 @@ export function sendToTerm(tab, data) {
   return send({ t: 'input', id: rec.sessionId, data });
 }
 
+/**
+ * The SERVER's session id this tab is bound to, or null. The scratchpad reads it: a pad belongs to
+ * the session, and the session's identity is this id — not the tab id (which survives a session
+ * being replaced) and not the session name (which repeats across repositories).
+ */
+export function sessionIdOf(tab) {
+  const rec = panes.get(tab && (tab.id || tab));
+  if (rec && rec.kind === 'real' && rec.sessionId) return rec.sessionId;
+  return (tab && tab.sessionId) || null;
+}
+
 /** Focus the terminal of a tab, if it is live. */
 export function focusTerm(tab) {
   const rec = panes.get(tab && (tab.id || tab));