Adom Gantt

@@ -3,6 +3,87 @@ Decisions taken while building, and the places where the plan and the code disagreed. Newest first. +## Build notes, 2026-11-03 (0.77.1, sections and the row order, after an afternoon on the team plan)++Drew: "this dropdown keeps disappearing on me, driving me absolutely nuts. Caused by+multiple users' activity?", then "why did that filter by user dropdown disappear on table+page?" and "with so many people working, be very careful to not clobber any of their+changes".++**What the team plan was doing.** From about 17:45 UTC three tabs were sending order+batches back and forth: the plan's revision went from 5343 to 5680 in two minutes with three+real edits in it. On the live stream every one of those batches was an `order` op, and two+orders alternated. One kept a new section's rows together; the other put 24 of them two+sections further down, at the top of a section they do not belong to. Each+announcement made every open tab rebuild its legend, which took the Owner filter out and+put it back, and that closed the owner list in the hand of whoever had it open.++**Causes, each reproduced on a copy of the live plan** (`incident.mjs`, `repro-loop.mjs`,+`repro-owner.mjs` in the gate folder):++1. *A catch-up did not see changes to created rows.* At 17:24 an agent moved 25 rows it had+   created into the new section with a whole-plan save that rewrote their entries in `added`.+   A tab catches up from a whole-plan save through `stateOps`, which turned only the+   overrides (`state.items`) into ops. 24 of those rows had no override, so the tabs open at+   the time kept them in their old section number, which now pointed one section further+   down. The one moved row that had an override came through. A fresh load was right.+2. *Tabs corrected the server's order.* A page lays its rows out grouped by section+   (`placeHeaders`), but the stored order is a flat list that a section change does not+   touch. A page compared its grouped order with the server's flat one and sent the+   difference as moves; two pages that grouped differently (cause 1) undid each other's+   moves for as long as both were open. On 0.77.0, 5.5 to 8 batches a second, indefinitely.+3. *A section move could be undone.* A batch that creates a section and moves rows into it+   reaches the other tabs rows first, because a page puts its section changes last and the+   server announced in arrival order. A tab refused a section number past the end of its+   list, but kept the server's value as the server's; its row then looked like an unsent+   edit of its own, and its next save sent the old section back. On 0.77.0, three rows+   moved into a new section were back in their old one after everybody's next save.+4. *The legend rebuilt under the owner list.* Every rebuild took Owner, Current and Overdue+   out and put them back, and a rebuild follows any change to the order or the tags. The+   list's scroll guard also closed it when the chart's panes scrolled under somebody else's+   change.+5. *The Table had an owner filter of its own*, at the far end of the legend line, and hid the+   chart's, so the filter seemed to vanish on the way into the Table.++**What changed.**++- Server: the stored order stays grouped by section after any batch that touches the+  order, a row's section or the section list, and the order op says so (`grouped: true`). A+  batch is announced sections first, then rows, then the order. Moves that leave the order as+  it was make no revision and no announcement. At every start the stored order is regrouped+  (when it lists every row) and the revision goes up by one, so a page that stayed open+  across the restart fetches the plan once.+- Page: orders are compared grouped by section (`groupOrder`) in `computeOps` and+  `rebaseOrder`, so grouping is never taken for a move. A batch is applied sections first,+  each op on its own: one that throws no longer takes the rest of the batch with it, and the+  page fetches the plan. A section the page cannot take leaves its copy of the server's value+  alone and fetches the plan. A page that groups a `grouped` order differently from the+  server fetches the plan (`requestResync`, at most every 10 s). A catch-up rebuilds every row+  as the server has it (the data-file row kept at load in `baseRowOf`, or the created row,+  with the overrides on top), not only the overrides.+- The legend keeps Owner, Current and Overdue in place and rewrites the owner list only when+  it changed; a scroll that cannot move a list's anchor leaves the list open; one Owner filter+  serves both lenses, in the same place.++**Tests.** collab_test `sections` (11 checks: the clobbered section move, two tabs that+missed a change with a third making one move, and the owner list staying open through field,+tag, order, delete and restore changes): 11/0 on 0.77.1; on 0.77.0 it fails 9 (the fight+check needs most of a section held two sections away, as on the day; a whole section moved+next door suits both groupings and does not fight). server_test section E, 10 checks.+ui_test uses the one Owner filter. Full runs: server 199/0, collaboration 91/0, the fuzz+with seeds 11 and 101 (six people) 5/0 each, UI 881/0 with the standing 7 controls+untested.++**After the deploy, rehearsed** (`rehearse.mjs`: 0.77.0 tabs fighting on a copy of the live+plan, then the server swapped on the same files and port). No row changed, no changelog line,+the sections the same. The 0.77.0 tab that was right stops sending at once, and a 0.77.1 tab+that joins matches the server and sends nothing. The two 0.77.0 tabs that hold rows in the+wrong section cannot put themselves right, because their catch-up is the old one: they keep+sending about 3.5 moves a second each until reloaded. Announcing each of those cost every+other open tab about 13 ms (110 ms a second on one tab, 125 on another); with no-op moves+unannounced it costs them nothing (5 and 0). So everybody reloads once after the deploy, and+the tabs that were open at 17:24 must.+ ## Build notes, 2026-10-30 (0.77.0, editing together the way Google Docs does)  Drew asked how Google Docs handles several people and undo, then: "build out the gdoc style

@@ -1681,8 +1681,6 @@ table.data-table { font-size: calc(12px * var(--fs)); min-width: calc(900px * va   </div>   <div class="table-view" id="tableView">     <div class="table-tools" id="tableTools">-      <label for="tblOwner">owner</label>-      <select id="tblOwner" title="Show only one person's work"></select>       <label for="tblStatus">status</label>       <!-- The five options are FILLED IN FROM STATUS_ORDER at startup (see            buildStatusFilter), not written out here. They were written out here until@@ -1850,6 +1848,10 @@ const importFileEl = $('importFile'); // ── Load data ── const projData = await fetch('data').then(r => r.json()); const { project, phases, items } = projData;+// Every data-file row as the file has it, before the sidecar touches it (0.77.1): a catch-up+// rebuilds each row as the server has it from this and the server's overrides.+const baseRowOf = new Map();+items.forEach(r => { if (r && r.uid) baseRowOf.set(r.uid, JSON.parse(JSON.stringify(r))); });  // ── Tags (0.59.0) ── //@@ -4546,6 +4548,17 @@ function moveInOrder(order,uid,after){   order.splice(after===null?0:order.indexOf(after)+1,0,uid);   return true; }+// The order as this page lays it out (placeHeaders): each section's rows together, sections+// in list order, rows in the given order inside a section, a row with no known section last.+// Orders are compared in this form (0.77.1), so a list that differs only in being grouped+// another way is never taken for rows somebody moved. Two pages that grouped the server's+// flat list differently each sent "moves" to fix it, and undid each other's for an hour.+function groupOrder(keys){+  const byKey=orderKeyMap(), buckets=phases.map(()=>[]), rest=[];+  keys.forEach(k=>{ const r=byKey.get(k), p=r?r.phase:undefined;+    if(Number.isInteger(p)&&p>=0&&p<buckets.length)buckets[p].push(k); else rest.push(k); });+  return [].concat(...buckets,rest);+} // The fewest rows to move to turn `base` into `target`, each as "after its new neighbour". // The rows that stay are the longest run already in the right relative order (a longest // increasing subsequence of their old positions); everything else moved, and so did any@@ -4581,7 +4594,7 @@ function computeOps(){     if(dead){ const d=rowDiff(ov,dead); if(d)rows.push(d); }   });   shadow.rows.forEach((_,u)=>{ if(!live.has(u))dels.push({op:'del',uid:u}); });-  const target=liveOrder(), base=shadow.order.filter(k=>live.has(k));+  const target=groupOrder(liveOrder()), base=groupOrder(shadow.order.filter(k=>live.has(k)));   let moves=orderMoves(base,target);   // The moves are checked by replaying them; if they would not land exactly on this   // page's order, the whole order goes instead, merged by the server like a move.@@ -5218,14 +5231,14 @@ function pullAndMerge(){   pullQueued=syncQ(async()=>{ pullQueued=null; pullCount++; await pullOnce(); });   return pullQueued; }-async function pullOnce(){+async function pullOnce(force){   if(SNAPSHOT)return;   const r=await fetch('state'); if(!r.ok)throw new Error('state '+r.status);   const st=await r.json();   const rev=st&&typeof st.stateRev==='number'?st.stateRev:0;   const late=inflight&&inflight.rev!==null&&inflight.rev<=rev;   if(!st||st.empty){ baseRev=Math.max(baseRev||0,rev); return; }-  if(rev<=(baseRev||0)&&!late)return;+  if(rev<=(baseRev||0)&&!late&&!force)return;   applyOps(stateOps(st),{actor:liveLastActor||'Someone'});   baseRev=Math.max(baseRev||0,rev);   // This tab's batch is already in what came back: whatever it sent and has not changed@@ -5247,19 +5260,28 @@ function stateOps(st){   added.forEach((_,u)=>{ if(!gone.has(u))live.add(u); });   shadow.rows.forEach((_,u)=>{ if(!live.has(u))ops.push({op:'del',uid:u}); });   const phaseN=Array.isArray(st.phases)&&st.phases.length&&st.phases.some(p=>p&&p.name!==undefined)?st.phases.length:phases.length;+  // Dependencies on a deleted row go with it, exactly as the server's merge drops them.+  const goneIds=new Set(); gone.forEach(u=>{ const b=added.get(u)||baseRowOf.get(u)||allRows.get(u); if(b&&b.id)goneIds.add(b.id); });   live.forEach(u=>{-    if(shadow.rows.has(u))return;+    if(shadow.rows.has(u)){+      // The server's WHOLE row, not only its overrides (0.77.1). A whole-plan save can change+      // a created row's own fields (its section, on 2026-11-03) and leave no override behind;+      // a page that read only the overrides never heard of it, and kept the row where it was.+      const base=added.get(u)||baseRowOf.get(u); if(!base)return;+      const row=Object.assign({},base); delete row._key;+      const sv=entries.get(u); if(sv)applyOverrideRow(row,sv,phaseN);+      const set=rowOv(row); delete set.uid;+      if(!('tags' in set))set.tags=[];+      if(Array.isArray(set.deps))set.deps=set.deps.filter(d=>!goneIds.has(d));+      ops.push({op:'row',uid:u,set});+      return;+    }     const base=added.get(u)||allRows.get(u);     if(!base)return;     const row=Object.assign({},base); delete row._lDiv; delete row._bDiv; delete row._msLine;     const sv=entries.get(u); if(sv)applyOverrideRow(row,sv,phaseN);     ops.push({op:'add',uid:u,row:addedOut(row)});   });-  entries.forEach((sv,u)=>{-    if(!live.has(u))return;-    const set={}; ROW_F.forEach(f=>{ if(sv[f]!==undefined)set[f]=cloneV(sv[f]); });-    ops.push({op:'row',uid:u,set});-  });   if(Array.isArray(st.order))ops.push({op:'order',order:st.order});   if(Array.isArray(st.phases)&&st.phases.length&&st.phases.some(p=>p&&p.name!==undefined))ops.push({op:'phases',phases:st.phases});   if(Array.isArray(st.tags))ops.push({op:'reg',tags:st.tags});@@ -5303,7 +5325,16 @@ function applyOps(ops,ctx){   try{     withTable(()=>withDeps(()=>{       inRowBatch(()=>{-        (ops||[]).forEach(op=>{ if(op&&typeof op==='object')applyOne(op,ctx.mine||null,ctx.self?'':ctx.actor||'Someone',T); });+        // Sections first, then rows, then the order (0.77.1): a row moved into a section that+        // is new in the same batch was refused when the row came first, and the page then+        // held the row's old section as an unsent edit of its own and sent it back.+        const rank=o=>(o.op==='phases'||o.op==='reg'||o.op==='dates'||o.op==='cal')?0:o.op==='order'?2:1;+        (ops||[]).filter(op=>op&&typeof op==='object').map((op,i)=>[op,i]).sort((a,b)=>rank(a[0])-rank(b[0])||a[1]-b[1]).forEach(([op])=>{+          // One op that cannot be applied must not take the rest of the batch with it; the+          // page fetches the whole plan instead of carrying on half-applied.+          try{ applyOne(op,ctx.mine||null,ctx.self?'':ctx.actor||'Someone',T); }+          catch(e){ T.resync='op'; try{ console.warn('adom-gantt: could not apply a change ('+op.op+'), fetching the plan:',e); }catch(_){} }+        });         if(ctx.settle)settleSent(ctx.settle,T);       });       repaintAfter(T,range0);@@ -5313,13 +5344,23 @@ function applyOps(ops,ctx){   }finally{ liveMerging=false; }   if(T.structure||T.phases||T.reg||T.dates||T.cal)lastSnap=snapSemantic();   else if(T.rows.size)patchSnap(T.rows);+  if(T.resync)requestResync(T.resync);   return T; }+// A full catch-up on purpose (0.77.1), for a page that found it disagrees with the server in a+// way no announcement will put right: a row in another section than the server has it, a+// value it could not take, an op it could not apply. What this page changed and has not sent+// is kept, as in every catch-up. At most one every ten seconds.+let resyncAt=0, resyncCount=0;+function requestResync(why){+  const now=Date.now(); if(now-resyncAt<10000)return; resyncAt=now; resyncCount++;+  syncQ(()=>pullOnce(true)).catch(()=>{});+} function applyOne(op,mine,who,T){   if(op.op==='row')return applyRowOp(op,mine,who,T);   if(op.op==='add')return applyAddOp(op,mine,who,T);   if(op.op==='del')return applyDelOp(op,mine,who,T);-  if(op.op==='order')return rebaseOrder(op.order,mine,T);+  if(op.op==='order')return rebaseOrder(op.order,mine,T,!!op.grouped);   const flying=k=>!mine&&!!inflight&&!!inflight.sent[k];   const sentDiff=(k,cur)=>mine&&mine.sent[k]?cur!==mine.struct[k]:false;   if(op.op==='phases'){@@ -5419,6 +5460,10 @@ function applyRowOp(op,mine,who,T){       continue;     }     setOvField(r,f,cloneV(next));+    // A section this page cannot take yet: its copy of the server's value stays what the row+    // shows, so the row is never taken for an edit of this page's own (sending it back would+    // undo the move for everybody), and the page fetches the plan to catch up.+    if(f==='phase'&&r.phase!==next){ sh[f]=old; T.resync='section'; continue; }     cur[f]=cloneV(next);     if(!mine){ remoteSeq.set(uid+'|'+f,++syncSeq); remoteWho.set(uid+'|'+f,who); remoteWho.set(uid+'|row',who); remoteRowSeq.set(uid,syncSeq); }     T.rows.add(r); T.fields.add(f);@@ -5486,15 +5531,17 @@ function applyDelOp(op,mine,who,T){ // The server's order, with this tab's own moves that it does not have yet replayed on top, // and any row this tab has that it does not list (made here and not sent yet) kept beside // the row it follows here.-function rebaseOrder(F,mine,T){+function rebaseOrder(F,mine,T,grouped){   if(!Array.isArray(F))return;   const old=shadow.order;   shadow.order=F.slice();-  const localOld=liveOrder();+  // Grouped as this page lays rows out, both sides (0.77.1): what this tab moved itself is+  // the difference between the two, and nothing that is only a matter of grouping.+  const raw=liveOrder(), localOld=groupOrder(raw);   const liveSet=new Set(localOld);   // Rows that arrived in this same batch take the server's place for them, not a guess.   const mineLocal=localOld.filter(k=>!T.fresh.has(k));-  const base=(mine&&mine.order?mine.order:old).filter(k=>liveSet.has(k)&&!T.fresh.has(k));+  const base=groupOrder(mine&&mine.order?mine.order:old).filter(k=>liveSet.has(k)&&!T.fresh.has(k));   const pend=orderMoves(base,mineLocal);   const res=F.filter(k=>liveSet.has(k));   const inRes=new Set(res);@@ -5504,7 +5551,14 @@ function rebaseOrder(F,mine,T){     res.splice(j<0?0:res.indexOf(localOld[j])+1,0,k); inRes.add(k);   });   pend.forEach(m=>moveInOrder(res,m.uid,m.after));-  if(res.join('\n')===localOld.join('\n'))return;+  // A server that keeps its order grouped (0.77.1) and a page that would group it otherwise+  // disagree about which section some row is in. Nothing announced will ever change that,+  // so the page fetches the whole plan, unless the difference is this page's own unsent move.+  if(grouped&&!mine&&!inflight&&!pend.length){+    const fl=F.filter(k=>liveSet.has(k));+    if(groupOrder(fl).join('\n')!==fl.join('\n')&&!computeOps().some(o=>o.op==='row'&&o.set&&'phase' in o.set))T.resync='sections';+  }+  if(res.join('\n')===raw.join('\n'))return;   if(applyOrder(res)){ T.structure=true; T.order=true; } } // What a batch sent and the server did not take, where this tab has not changed it since,@@ -5729,7 +5783,12 @@ window.__collab={pause:stopLive,resume:startLive,people:()=>livePeople.slice(),m   del:uid=>{ const r=liveRowOf(uid); if(!r)return false; deleteRow(r); return true; },   undo:()=>undo(), redo:()=>redo(),   dates:()=>Object.assign({},planDates), cal:()=>JSON.parse(JSON.stringify(planCal)),-  addBiz:(d,n)=>addBiz(d,n), workdays:(a,b)=>bizBetween(a,b), offDay:d=>isOffDay(d), axis:()=>({start:isoDay(START),col:COL}), busy:()=>!!pullQueued||syncBusy||!!inflight||saveInFlight||!!saveTimer};+  addBiz:(d,n)=>addBiz(d,n), workdays:(a,b)=>bizBetween(a,b), offDay:d=>isOffDay(d), axis:()=>({start:isoDay(START),col:COL}), busy:()=>!!pullQueued||syncBusy||!!inflight||saveInFlight||!!saveTimer,+  // A page that missed a change, for the suite (0.77.1): these rows put in another section on+  // the page AND in its copy of the server's values, which is what a lost announcement leaves+  // behind. Nothing it sends or hears afterwards would show it; only a catch-up puts it right.+  diverge:(uids,ph)=>{ let n=0; uids.forEach(u=>{ const r=liveRowOf(u), sh=shadow.rows.get(u); if(!r||!sh)return; r.phase=ph; sh.phase=ph; n++; }); placeHeaders(); reflowRows(); drawDeps(); return n; },+  resyncs:()=>resyncCount}; // One save landed. Anything the banner was waiting for is now settled, and the queued // changelog lines go out BEHIND the state they describe, never in front of it. function onSaveOk(msg){@@ -6115,7 +6174,9 @@ function syncTagToggle(n,chosen){ // select, so it hides in the table view, where that one sits in the toolbar. const ownerPick=document.createElement('div'), ownerPickSel=document.createElement('select'), overdueChip=document.createElement('button'), currentChip=document.createElement('button'); function wireLegendOwner(){-ownerPick.className='legend-item owner-pick gantt-only';+// Both lenses (0.77.1). The Table had a filter of its own at the far end of the line, so the+// chart's one seemed to vanish on the way into the Table; it is the same choice, in one place.+ownerPick.className='legend-item owner-pick'; ownerPick.innerHTML='<span class="op-label">Owner</span>'; ownerPickSel.id='ganttOwner'; ownerPickSel.setAttribute('aria-label','Owner filter'); ownerPickSel.title="Show only one person's rows, or the ones nobody owns yet. Your view only, it does not change the plan.";@@ -6145,7 +6206,10 @@ function syncOwnerPick(){   // An owner who no longer has a row drops out of the filter, the way a vanished tag   // does, so nobody is left looking at an empty chart for a reason they cannot see.   if(prefs.ownerFilter&&prefs.ownerFilter!==OWNER_NONE&&!names.includes(prefs.ownerFilter)){ prefs.ownerFilter=''; savePrefs(); }-  ownerPickSel.innerHTML=html; ownerPickSel.value=prefs.ownerFilter;+  // Only when the list itself changed: rewriting it under an open list or a keyboard walk+  // would move the highlight for nothing (0.77.1).+  if(ownerPickSel._html!==html){ ownerPickSel.innerHTML=html; ownerPickSel._html=html; }+  if(ownerPickSel.value!==prefs.ownerFilter)ownerPickSel.value=prefs.ownerFilter;   ownerPick.classList.toggle('on',ownerFilterOn()); } // Tasks and milestones are counted apart. On a real plan most milestones carry no status@@ -6227,12 +6291,15 @@ function syncSecToggle(){ } function rebuildLegend(){   legendEl.querySelectorAll('.phase-chip,.tag-chip').forEach(el=>el.remove());-  [secToggle,tagClear,tagToggle,ownerPick,currentChip,overdueChip].forEach(el=>{ if(el.isConnected)el.remove(); });-  const first=collapseAllBtn.isConnected?collapseAllBtn.nextSibling:legendEl.firstChild;+  [secToggle,tagClear,tagToggle].forEach(el=>{ if(el.isConnected)el.remove(); });+  // The owner filter and the two chips stay put (0.77.1). They were taken out and put back+  // on every rebuild, and a rebuild follows any change to the plan's order, so somebody+  // else's drag closed the owner list in the hand of whoever had it open.+  let at=collapseAllBtn.isConnected?collapseAllBtn.nextSibling:legendEl.firstChild;+  [ownerPick,currentChip,overdueChip].forEach(el=>{ if(el!==at)legendEl.insertBefore(el,at); at=el.nextSibling; });+  syncOwnerPick(); syncCurrentChip(); syncOverdueChip();+  const first=at;   const put=el=>legendEl.insertBefore(el,first);-  syncOwnerPick(); put(ownerPick);-  syncCurrentChip(); put(currentChip);-  syncOverdueChip(); put(overdueChip);   const tags=usedTags(), ks=tagFilterKeys(), filtering=tags.length>0&&tagFilterOn();   if(tags.length){ syncTagToggle(tags.length,tags.filter(e=>ks.has(e.key)).length); put(tagToggle); }   const tOpen=tagsOpen(tags.length);@@ -12001,7 +12068,7 @@ window.addEventListener('resize',()=>{ // the table is a separate store.  const tableBody=$('tableBody'), tableHead=$('tableHead'), ownerListEl=$('ownerList');-const ownerSel=$('tblOwner'), statusSel=$('tblStatus'), searchInp=$('tblSearch'), countEl=$('tblCount');+const statusSel=$('tblStatus'), searchInp=$('tblSearch'), countEl=$('tblCount'); const STATUS_OPTS=STATUS_ORDER; const UNASSIGNED='__unassigned__';   // sentinel, so a real owner can never collide with it // null means plan order: the order the rows are actually in, which is the only@@ -12123,16 +12190,9 @@ function buildStatusFilter(){     STATUS_ORDER.map(k=>`<option value="${k}">${esc(statusTextFor(k))}</option>`).join('')); } function syncOwnerControls(){-  const owners=distinctOwners();-  // On the first render there are no options yet, so a value set from prefs would-  // not have stuck. Fall back to the saved filter rather than the empty select.-  const cur=prefs.ownerFilter||'';-  ownerSel.innerHTML='<option value="">All owners</option>'-    +owners.map(o=>`<option value="${esc(o)}">${esc(o)}</option>`).join('')-    +`<option value="${UNASSIGNED}">Unassigned</option>`;-  ownerSel.value = (cur===''||cur===UNASSIGNED||owners.includes(cur)) ? cur : '';-  // Typing an owner offers the names already on the plan without forcing them.-  ownerListEl.innerHTML=owners.map(o=>`<option value="${esc(o)}"></option>`).join('');+  // Typing an owner offers the names already on the plan without forcing them. The filter+  // itself is the legend's (syncOwnerPick), shared by both lenses since 0.77.1.+  ownerListEl.innerHTML=distinctOwners().map(o=>`<option value="${esc(o)}"></option>`).join(''); }  // The value a column sorts on. It lives out here rather than inside tableRows@@ -12886,7 +12946,13 @@ function inOwnPopup(ev){   const t=ev&&ev.target;   return !!(t&&t.nodeType===1&&t.closest&&t.closest('.cell-list')); }-function popupScrollGuard(close){ return ev=>{ if(!inOwnPopup(ev))close(); }; }+// A scroll that cannot move the anchor leaves the list open (0.77.1): the chart's panes scroll+// on their own when somebody else's change lands, and that closed a list opened in the legend.+function popupScrollGuard(close,anchor){ return ev=>{+  if(inOwnPopup(ev))return;+  const t=ev&&ev.target;+  if(anchor&&t&&t.nodeType===1&&!t.contains(anchor))return;+  close(); }; } // The OTHER half of the same report. Both lists cancel mousedown, for two good reasons // (never steal focus from the offscreen select, never let the native select popup open // on top of ours), but they cancelled it everywhere on the element including its own@@ -13260,7 +13326,7 @@ function openCellList(sel,td){     sel.dispatchEvent(new Event('change',{bubbles:true}));   });   cellList={el,sel};-  cellListScroll=popupScrollGuard(closeCellList);+  cellListScroll=popupScrollGuard(closeCellList,td);   window.addEventListener('scroll',cellListScroll,true);   window.addEventListener('resize',closeCellList);   syncCellList();@@ -13676,8 +13742,7 @@ if(b)b.addEventListener('click',e=>{e.stopPropagation();copySelectedIds();}); function wireTableFilters(){ // The toolbar's filters are our list too (0.72.0): typing and the arrows highlight, Enter or // a click applies, the same as every other list.-wireAppSelect(ownerSel); wireAppSelect(statusSel);-ownerSel.addEventListener('apppick',()=>setOwnerFilter(ownerSel.value));+wireAppSelect(statusSel); statusSel.addEventListener('apppick',renderTable); searchInp.addEventListener('keydown',e=>e.stopPropagation()); searchInp.addEventListener('input',()=>{clearTimeout(tblSearchTimer);tblSearchTimer=setTimeout(renderTable,120);});@@ -14219,7 +14284,7 @@ rebuildTimeline(); sizeTailroom(); drawDeps(); // "What's mine" is a standing question, so the owner filter survives a reload-// (syncOwnerControls picks prefs.tableOwner up on this first render).+// (syncOwnerPick picks the saved owner filter up on this first render). renderTable(); // The sidecar can add or drop a dependency, so what the two plan buttons are allowed // to do is only settled once it is in.

@@ -1482,7 +1482,7 @@ function applyOpsTo(state, data, mergedByUid, ops, mayDate) {     if (!o) { const base = mergedByUid.get(uid); o = base ? overrideOf(base) : { uid }; entries.set(uid, o); state.items.push(o); }     return o;   };-  let orderTouched = false;+  let orderTouched = false, phasesTouched = false, moved = false;   const moves = [];   // A row coming back: off the deleted list, and announced whole, as the merge reads it.   const undelete = uid => {@@ -1576,7 +1576,7 @@ function applyOpsTo(state, data, mergedByUid, ops, mayDate) {     } else if (op.op === 'move') {       if (!uid) { refused.push('move: no uid'); continue; }       moves.push({ uid, after: typeof op.after === 'string' ? op.after.slice(0, 40) : null });-      orderTouched = true;+      moved = true;     } else if (op.op === 'phases') {       if (!Array.isArray(op.phases) || !op.phases.length || !op.phases.every(p => p && typeof p === 'object' && typeof p.name === 'string')) { refused.push('phases'); continue; }       state.phases = op.phases.map((p, i) => { const o = { i, name: p.name.slice(0, 200), start: typeof p.start === 'string' ? p.start : '', end: typeof p.end === 'string' ? p.end : '' };@@ -1584,6 +1584,7 @@ function applyOpsTo(state, data, mergedByUid, ops, mayDate) {         if (typeof p.color === 'string' && p.color) o.color = p.color.slice(0, 40);         o.tags = normalizeTags(p.tags) || []; return o; });       out.push({ op: 'phases', phases: state.phases.map(p => Object.assign({}, p)) });+      phasesTouched = true;     } else if (op.op === 'reg') {       const t = normalizeTagRegistry(op.tags);       if (!t) { refused.push('reg'); continue; }@@ -1599,9 +1600,16 @@ function applyOpsTo(state, data, mergedByUid, ops, mayDate) {   // The order is kept complete, every live row exactly once, because the merge reads it   // all or nothing. A row it does not list yet (just created) goes to the end of its own   // section, then the moves are replayed on top, in the order they were made.-  if (orderTouched) {-    const live = liveKeyList(data, state), liveSet = new Set(live);-    const phaseOf = u => { const o = entries.get(u); if (o && Number.isInteger(o.phase)) return o.phase; const r = mergedByUid.get(u); return r ? r.phase : undefined; };+  //+  // And it is kept GROUPED BY SECTION (0.77.1), the way every page lays its rows out. A row+  // moved to another section by its section field alone, or a section moved in the list,+  // used to leave the stored order as it was. Every open page then grouped it differently+  // from the server and sent moves to "fix" the server's copy; on 2026-11-03 two pages that+  // disagreed about which section 24 rows were in corrected each other three times a+  // second for an hour, and every other page redrew each time.+  if (orderTouched || moved || phasesTouched) {+    const live = liveKeyList(data, state), liveSet = new Set(live), n = sectionCount(state, data);+    const phaseOf = u => { const o = entries.get(u); if (o && Number.isInteger(o.phase) && o.phase >= 0 && o.phase < n) return o.phase; const r = mergedByUid.get(u); return r ? r.phase : undefined; };     let cur = Array.isArray(state.order) ? state.order : live.filter(k => dataUids.has(k));     cur = [...new Set(cur.filter(k => liveSet.has(k)))];     const inCur = new Set(cur);@@ -1614,11 +1622,55 @@ function applyOpsTo(state, data, mergedByUid, ops, mayDate) {       inCur.add(k);     });     moves.forEach(m => moveInOrder(cur, m.uid, m.after));+    cur = groupBySection(cur, phaseOf, n);+    const changed = !Array.isArray(state.order) || cur.join('\n') !== state.order.join('\n');     state.order = cur;-    out.push({ op: 'order', order: cur.slice() });+    // `grouped` tells a page it can trust the order to match its own layout: one that does+    // not, groups some row into another section than the server does, and fetches the plan.+    // Moves that leave the order as it was make no revision and are announced to nobody: a+    // 0.77.0 page that holds rows in the wrong section keeps sending them until it is+    // reloaded, and announcing each one cost every other open page about 13 ms, eight times+    // a second (measured on a copy of the team plan). Rows added, deleted or moved to another+    // section always send the order, because pages regroup on it.+    if (orderTouched || changed) out.push({ op: 'order', order: cur.slice(), grouped: true });   }+  // Sections first, then rows, then the order (0.77.1). A page applies an announcement in+  // the order it is given, and a page that had not got a section yet refused a row moved+  // into it; it then held the row's old section as an edit of its own, and its next save+  // sent the old section back, undoing the move for everybody.+  const rank = o => (o.op === 'phases' || o.op === 'reg' || o.op === 'dates' || o.op === 'cal') ? 0 : o.op === 'order' ? 2 : 1;+  out.sort((a, b) => rank(a) - rank(b));   return { out, refused }; }+function resyncOnStart() {+  try {+    const st = loadState();+    if (!st || typeof st !== 'object' || Array.isArray(st) || st.v !== 4) return;+    const merged = mergedData(), items = merged.items || [];+    const phaseOf = new Map(items.map(r => [r && r.uid, r && r.phase]));+    // Only an order that lists exactly the plan's rows: that is the one the merge applies,+    // and anything else is left for the next save that touches the order to complete.+    if (Array.isArray(st.order) && st.order.length === items.length && st.order.every(u => phaseOf.has(u))) {+      st.order = groupBySection(st.order, u => phaseOf.get(u), (merged.phases || []).length);+    }+    st.stateRev = (typeof st.stateRev === 'number' ? st.stateRev : 0) + 1;+    writeAtomic(STATE_FILE, JSON.stringify(st));+  } catch (e) { console.error('Start: the saved order was not regrouped (' + e.message + ')'); }+}+// How many sections the plan has with this sidecar applied: its own full list when it+// carries one, the data file's otherwise. A row's section is an index into that list.+function sectionCount(state, data) {+  const sph = state && state.phases;+  return Array.isArray(sph) && sph.length && sph.some(p => p && p.name !== undefined) ? sph.length : ((data && data.phases) || []).length;+}+// The pages' layout (placeHeaders in gantt.html): each section's rows together, sections in+// list order, rows in their saved order inside a section, and a row whose section is not in+// the list at the end rather than dropped.+function groupBySection(keys, phaseOf, n) {+  const buckets = Array.from({ length: n }, () => []), rest = [];+  keys.forEach(k => { const p = phaseOf(k); if (Number.isInteger(p) && p >= 0 && p < n) buckets[p].push(k); else rest.push(k); });+  return [].concat(...buckets, rest);+} function tidyStateTags(st) {   if (!st || typeof st !== 'object' || Array.isArray(st)) return st;   const side = o => {@@ -3587,6 +3639,12 @@ ensureUids('startup'); // Second, and only ever after the first: the upgrade rewrites the sidecar's keys // as uids, which requires every row to have one. ensureStateV4();+// Third (0.77.1): one revision at every start. The saved order is put in section order, and+// every page that stayed open across the restart sees a newer revision when its stream+// reconnects, so it fetches the whole plan once. That is how a page that missed a change is+// put right without anybody reloading it (2026-11-03: two pages held 24 rows in another+// section than the server did, and nothing else would ever have told them).+resyncOnStart();  // The digest tick: decides on its own whether anything is due, so a quiet plan costs one // small file read every 15 seconds and nothing else.

@@ -14,7 +14,7 @@ //   node test/collab_test.mjs --users 12           a bigger meeting //   node test/collab_test.mjs --throttle 4         every tab on a CPU four times slower //   node test/collab_test.mjs --only meeting,soak  some scenarios (join merge meeting presence-//                                                  idle soak conflict reconnect docs fuzz)+//                                                  idle soak conflict reconnect docs fuzz sections) //   node test/collab_test.mjs --plan my.json       a real plan (and its -state.json) instead //   node test/collab_test.mjs --seconds 120        a longer meeting //   node test/collab_test.mjs --app ../old-build   measure another build (checks that need@@ -93,7 +93,7 @@ const fmtMs = v => Math.round(v) + ' ms'; // created in the app (the sidecar's `added`, which startup inserts one by one), 5 deleted, // ~190 dependencies, owners, statuses, notes and tags. Seeded, so every run is the same plan. function rng(seed) { let s = seed >>> 0; return () => { s = (s * 1664525 + 1013904223) >>> 0; return s / 4294967296; }; }-const PEOPLE = ['Drew Owens', 'Kaley Mer', 'Noah Ash', 'Colby Knox', 'Adonis Ray', 'Caleb Stone', 'Ana Lopez', 'Bo Chen', 'Cy Diaz', 'Di Evans', 'Ed Fox', 'Flo Gray'];+const PEOPLE = ['Drew Owens', 'Kale Mer', 'Noah Ash', 'Colby Knox', 'Adonis Ray', 'Caleb Stone', 'Ana Lopez', 'Bo Chen', 'Cy Diaz', 'Di Evans', 'Ed Fox', 'Flo Gray']; const STATUSES = ['not-started', 'not-started', 'not-started', 'in-progress', 'in-progress', 'complete', 'blocked', 'cancelled']; const TAGS = ['Launch', 'Fab', 'Order', 'Assembly', 'Post-process', 'Ops']; function makePlan() {@@ -709,12 +709,12 @@ async function docsScenario(carbon) {   // 1. Two fields of one row, at the same moment: neither tab hears the other first.   const r1 = rows[3];   await pause();-  await setF(A, r1.uid, 'owner', 'Kaley Mer'); await setF(Bp, r1.uid, 'status', 'blocked');+  await setF(A, r1.uid, 'owner', 'Kale Mer'); await setF(Bp, r1.uid, 'status', 'blocked');   await sent(both); await resume();   let g = await srvRow(r1.uid);-  check('two people change two different fields of one row at the same moment: both are kept', g.owner === 'Kaley Mer' && g.status === 'blocked', JSON.stringify([g.owner, g.status]));+  check('two people change two different fields of one row at the same moment: both are kept', g.owner === 'Kale Mer' && g.status === 'blocked', JSON.stringify([g.owner, g.status]));   let ta = await tabRow(A, r1.uid), tb = await tabRow(Bp, r1.uid);-  check('and both tabs show both', ta.owner === 'Kaley Mer' && tb.owner === 'Kaley Mer' && ta.status === 'blocked' && tb.status === 'blocked', JSON.stringify([ta.owner, ta.status, tb.owner, tb.status]));+  check('and both tabs show both', ta.owner === 'Kale Mer' && tb.owner === 'Kale Mer' && ta.status === 'blocked' && tb.status === 'blocked', JSON.stringify([ta.owner, ta.status, tb.owner, tb.status]));    // 2. One field, at the same moment: the later save wins it, everywhere.   const r2 = rows[7];@@ -730,8 +730,8 @@ async function docsScenario(carbon) {   await setF(A, r3.uid, 'owner', 'Bo Chen'); await quiesce(S, both);   await setF(Bp, r3.uid, 'owner', 'Cy Diaz'); await quiesce(S, both);   const notes = await A.page.evaluate(() => window.__collab.notices());-  check('a value replaced a moment later is not lost silently: its writer is told who replaced it and what they had', notes.some(n => n.uid === r3.uid && n.f === 'owner' && n.who === 'Kaley Mer' && n.was === 'Bo Chen' && n.to === 'Cy Diaz'), JSON.stringify(notes.slice(-3)));-  check('and sees it said on screen', /Kaley Mer changed the owner of .* to Cy Diaz just now \(you had Bo Chen\)/.test(await A.page.$eval('#saveInd', e => e.textContent)), await A.page.$eval('#saveInd', e => e.textContent));+  check('a value replaced a moment later is not lost silently: its writer is told who replaced it and what they had', notes.some(n => n.uid === r3.uid && n.f === 'owner' && n.who === 'Kale Mer' && n.was === 'Bo Chen' && n.to === 'Cy Diaz'), JSON.stringify(notes.slice(-3)));+  check('and sees it said on screen', /Kale Mer changed the owner of .* to Cy Diaz just now \(you had Bo Chen\)/.test(await A.page.$eval('#saveInd', e => e.textContent)), await A.page.$eval('#saveInd', e => e.textContent));    // 4. Lists merge item by item: two people add a different dependency, and a different tag.   const r4 = rows[12], c4 = await tabRow(A, r4.uid);@@ -762,7 +762,7 @@ async function docsScenario(carbon) {   g = await srvRow(r6.uid);   const kept6 = await A.page.evaluate(() => window.__collab.kept());   check('undo does not take back a teammate\'s newer value of the field you changed', g.owner === 'Flo Gray', g.owner);-  check('and the toast names whose value it kept', kept6.some(k => k.uid === r6.uid && k.f === 'owner' && k.who === 'Kaley Mer') && /kept Kaley Mer's newer owner/.test(await A.page.$eval('#undoToast', e => e.textContent)), JSON.stringify(kept6) + ' ' + await A.page.$eval('#undoToast', e => e.textContent));+  check('and the toast names whose value it kept', kept6.some(k => k.uid === r6.uid && k.f === 'owner' && k.who === 'Kale Mer') && /kept Kale Mer's newer owner/.test(await A.page.$eval('#undoToast', e => e.textContent)), JSON.stringify(kept6) + ' ' + await A.page.$eval('#undoToast', e => e.textContent));   // 7. A list item: undo takes out the dependency you added, not the one a teammate added after.   const r7 = rows[30], c7 = await tabRow(A, r7.uid);   const e1 = rows.find(r => r.uid !== r7.uid && !c7.deps.includes(r.id)).id, e2 = rows.find(r => r.uid !== r7.uid && r.id !== e1 && !c7.deps.includes(r.id)).id;@@ -797,7 +797,7 @@ async function docsScenario(carbon) {   const made = (await planRows(S, A.sid)).find(r => r.name === 'Made by Drew');   check('a row made in one tab reaches the server', !!made);   if (made) {-    await setF(Bp, made.uid, 'owner', 'Kaley Mer'); await quiesce(S, both);+    await setF(Bp, made.uid, 'owner', 'Kale Mer'); await quiesce(S, both);     await A.page.evaluate(() => window.__collab.undo()); await quiesce(S, both);     check('undoing the creation of a row a teammate has since changed keeps the row', !!(await srvRow(made.uid)) && (await A.page.evaluate(() => window.__collab.kept())).some(k => k.f === 'row'), JSON.stringify(await A.page.evaluate(() => window.__collab.kept())));   }@@ -824,6 +824,94 @@ async function docsScenario(carbon) { // undo and redo, with tabs dropping off the live channel and coming back. Afterwards every // tab must hold exactly what the server holds, and a field only one person ever wrote must // end as that person left it: whole-row saving lost exactly those.+// ═════════════════════════════════════════════════════════════════════════════+// Sections (0.77.1), the team plan's incident of 2026-11-03, all three parts of it. A batch+// that created a section and moved rows into it reached open tabs rows first; they refused+// the move and their next saves sent the old section back. Two tabs that had missed a+// change to created rows held them in another section than the server, and corrected the+// server's order against a third tab three times a second, for an hour. And each of those+// corrections rebuilt the legend, which closed the owner list in the hand that had it open.+// ═════════════════════════════════════════════════════════════════════════════+async function sectionsScenario(carbon) {+  scenario = 'sections';+  const S = await startServer(carbon);+  const people = [];+  for (let i = 0; i < 3; i++) people.push(await openPerson(S, carbon, i));+  for (const P of people) await goReady(P, S);+  await sleep(1500);+  const [A, Bp, Cp] = people;+  const can = await A.page.evaluate(() => !!(window.__collab && window.__collab.set && window.__collab.diverge));+  if (!can) { skip('sections', 'this build cannot make a tab miss a change (no __collab.diverge)'); for (const P of people) await closePerson(P); await stopServer(S); return; }+  const H = { Authorization: 'Bearer ' + S.token, 'Content-Type': 'application/json' };+  const rows = await A.page.evaluate(() => window.__collab.rows());+  const inSec = p => rows.filter(r => r.phase === p && r.start);+  const secs = [...new Set(rows.map(r => r.phase))].filter(p => inSec(p).length >= 4).sort((a, b) => a - b);+  const srvPhase = async () => new Map((await planRows(S, A.sid)).map(r => [r.uid, r.phase]));+  const posts = P => { P.ops = []; P.page.on('request', r => { if (r.method() === 'POST' && r.url().split('?')[0].endsWith('/ops')) P.ops.push(Date.now()); }); };+  people.forEach(posts);++  // 1. One batch creates a section at the end and moves rows into it, rows first.+  const st = await (await fetch(S.base + '/state', { headers: H })).json();+  const ph = st.phases.map(p => ({ name: p.name, start: p.start || '', end: p.end || '', uid: p.uid, color: p.color, tags: p.tags || [] }));+  const N = ph.length; ph.push({ name: 'Created and filled at once', start: '', end: '', color: '#56ccf2', tags: [] });+  const movers = inSec(secs[0]).slice(0, 3).map(r => r.uid);+  const res = await (await fetch(S.base + '/ops', { method: 'POST', headers: H,+    body: JSON.stringify({ client: 'agent', batch: 'sec-1', ops: movers.map(u => ({ op: 'row', uid: u, set: { phase: N } })).concat([{ op: 'phases', phases: ph }]) }) })).json();+  check('a batch that creates a section and moves rows into it is announced sections first', res.ok && (res.ops || [])[0] && res.ops[0].op === 'phases', (res.ops || []).map(o => o.op).join(' > '));+  await quiesce(S, people);+  // Everybody then edits something else, so whatever a tab holds goes out with its save.+  const busy = inSec(secs[1]);+  for (let i = 0; i < 3; i++) await setF(people[i], busy[i].uid, 'status', 'in-progress');+  await quiesce(S, people); await sleep(600);+  let sp = await srvPhase();+  check('the rows moved into the new section stay there through everybody\'s next save (nobody sends the old section back)', movers.every(u => sp.get(u) === N), movers.map(u => sp.get(u)).join(','));+  const shown = await Promise.all(people.map(P => P.page.evaluate(m => m.map(u => (window.__collab.rows().find(r => r.uid === u) || {}).phase), movers)));+  check('and every tab shows them in it', shown.every(l => l.every(p => p === N)), JSON.stringify(shown));++  // 2. Two tabs miss a change: rows held in another section, on the page and in its copy of+  // the server's values. A third tab makes one ordinary move.+  // As on the day: most of a section, not all of it, held two sections further down, so no+  // one order can suit both ways of grouping and each side keeps correcting the other.+  const lost = inSec(secs[1]).slice(2).map(r => r.uid), wrong = secs[3];+  for (const P of [Bp, Cp]) await P.page.evaluate(([u, p]) => window.__collab.diverge(u, p), [lost, wrong]);+  const r0 = await Promise.all([Bp, Cp].map(P => P.page.evaluate(() => window.__collab.resyncs ? window.__collab.resyncs() : 0)));+  const mv = inSec(secs[4] !== undefined ? secs[4] : secs[0]);+  const t0 = Date.now();+  await A.page.evaluate(([u, w]) => window.__collab.move(u, w), [mv[0].uid, mv[2].uid]);+  const per = [];+  for (let k = 0; k < 10; k++) { await sleep(1000); per.push(people.reduce((n, P) => n + P.ops.filter(x => x >= t0 + k * 1000 && x < t0 + (k + 1) * 1000).length, 0)); }+  rec('batchesPerSecondAfterOneMove', per);+  check('one move with two tabs that missed a change: the tabs go quiet, no fight over the order', per.slice(-5).every(n => n === 0), per.join(' '));+  sp = await srvPhase();+  for (const P of [Bp, Cp]) {+    const rs = await P.page.evaluate(() => window.__collab.rows());+    const off = lost.filter(u => (rs.find(r => r.uid === u) || {}).phase !== sp.get(u));+    const r1 = await P.page.evaluate(() => window.__collab.resyncs ? window.__collab.resyncs() : 0);+    check(`${P.name}'s tab notices it disagrees about the sections, fetches the plan and puts the ${lost.length} rows back`, off.length === 0, `${off.length} still elsewhere, catch-ups ${r1 - r0[[Bp, Cp].indexOf(P)]}`);+  }+  check('the server never took the wrong section from them', lost.every(u => sp.get(u) === secs[1]));+  const orders = await Promise.all(people.map(P => P.page.evaluate(() => window.__collab.order().join(','))));+  check('and all three tabs hold the same order', orders.every(o => o === orders[0]));+  check('every tab holds exactly what the server holds', (await convergence(S, people)).length === 0);++  // 3. The owner list stays open in one hand while the others change the plan.+  const listOpen = () => A.page.evaluate(() => !!document.querySelector('.cell-list') && document.activeElement === document.getElementById('ganttOwner'));+  await A.page.click('#ganttOwner'); await sleep(300);+  const before = await listOpen();+  const t1 = inSec(secs[2]);+  await setF(Bp, t1[0].uid, 'status', 'blocked'); await quiesce(S, people);+  await setF(Cp, t1[1].uid, 'tags', ['Moved', 'Here']); await quiesce(S, people);+  await Cp.page.evaluate(([u, w]) => window.__collab.move(u, w), [t1[2].uid, t1[3].uid]); await quiesce(S, people);+  await Bp.page.evaluate(u => window.__collab.del(u), t1[1].uid); await quiesce(S, people);+  await Bp.page.evaluate(() => window.__collab.undo()); await quiesce(S, people);+  check('an open owner list stays open while other people change fields, tags, the order, and delete and restore a row', before && await listOpen());+  await A.page.keyboard.press('Escape');+  const errs = people.flatMap(P => P.errors);+  check('no page errors', errs.length === 0, errs.slice(0, 3).join(' | '));+  for (const P of people) await closePerson(P);+  await stopServer(S);+}+ async function fuzzScenario(carbon) {   scenario = 'fuzz';   const S = await startServer(carbon);@@ -925,6 +1013,7 @@ try {   if (want('reconnect')) await reconnectScenario(carbon);   if (want('docs')) await docsScenario(carbon);   if (want('fuzz')) await fuzzScenario(carbon);+  if (want('sections')) await sectionsScenario(carbon);   exitCode = fail ? 1 : 0; } catch (e) {   console.error('\nSUITE CRASHED:', e && e.stack || e);