@floless/app 0.75.0 → 0.76.0

package/dist/web/app.css

@@ -3344,6 +3344,8 @@ body {
 .app.mode-workspaces .notes-strip, .app.mode-workspaces .find-overlay,
 /* the ws surfaces carry their own headings — hide the canvas's "Canvas · transparency layer" label */
 .app.mode-workspaces .canvas > .panel-label { display:none !important; }
+/* …but Find in model reuses that overlay — un-hide it while open (Ctrl+F searches editor members). */
+.app.mode-workspaces .find-overlay.show { display: flex !important; }
 /* the editor owns center+right in a project — collapse the inspect column entirely */
 .app.mode-workspaces { --right-width:0px !important; }
 .app.mode-workspaces .inspect { display:none; }
@@ -3473,9 +3475,26 @@ table.hist tr.current td { background:var(--accent-soft); }
 .hist .gate-badge { display:inline-block; padding:2px 7px; border-radius:4px; font-size:9.5px; font-weight:600;
   text-transform:uppercase; letter-spacing:.05em; background:transparent; border:1px solid var(--border-strong); color:var(--text-dim); }
 .hist .gate-badge.model { background:var(--accent-soft); border-color:var(--accent-dim); color:var(--accent-bright); }
-.hist .btn-mini { background:none; border:1px solid var(--border-strong); color:var(--text-muted); border-radius:6px;
+.hist .btn-mini, .ws-drawings-bar .btn-mini, .ws-revision-card .btn-mini { background:none; border:1px solid var(--border-strong); color:var(--text-muted); border-radius:6px;
   padding:4px 10px; font-size:11px; cursor:pointer; white-space:nowrap; }
-.hist .btn-mini:hover { color:var(--text); border-color:var(--accent); }
+.hist .btn-mini:hover, .ws-drawings-bar .btn-mini:hover, .ws-revision-card .btn-mini:hover { color:var(--text); border-color:var(--accent); }
+
+/* ── Workspaces: revision re-read (Slice 4b) — attach band + pending/failed card ── */
+.ws-drawings-bar { flex:none; display:flex; align-items:center; gap:10px; padding:8px 14px; border-bottom:1px solid var(--border); background:var(--surface); }
+.ws-drawings-bar[hidden] { display:none !important; }
+.ws-drawings-bar-label { font-size:10px; color:var(--text-dim); text-transform:uppercase; letter-spacing:.1em; }
+.ws-drawings-bar-sep { flex:1; }
+.ws-revision-card { flex:none; display:flex; align-items:center; gap:10px; padding:9px 14px; border-bottom:1px solid var(--border); background:var(--surface-2); font-size:12px; color:var(--text-muted); }
+.ws-revision-card[hidden] { display:none !important; }
+.ws-revision-card b { color:var(--text); font-weight:600; }
+.ws-revision-card .wrc-text { flex:1; min-width:0; }
+.ws-revision-card .wrc-spin { flex:none; width:14px; height:14px; border:2px solid var(--border-strong); border-top-color:var(--accent); border-radius:50%; animation:spin .8s linear infinite; }
+.ws-revision-card.state-failed { border-left:3px solid var(--err); }
+.ws-revision-card.state-failed .wrc-err-ico { color:var(--err); flex:none; }
+.ws-revision-card.state-failed .wrc-err-detail { color:var(--text-dim); }
+.ws-revision-card .wrc-actions { display:flex; gap:6px; flex:none; }
+@media (prefers-reduced-motion: reduce) { .ws-revision-card .wrc-spin { animation:none; } }
+.hist .gate-badge.ai-read { background:var(--accent-soft); border-color:var(--accent-dim); color:var(--accent-bright); }
 
 /* Rollback confirm — a styled anchored popover (NEVER a native dialog); names the Exports re-lock. */
 .hist-confirm { position:absolute; z-index:20; width:264px; padding:12px 13px; background:var(--surface-3);

package/dist/web/app.js

@@ -1094,6 +1094,10 @@ const $findInput   = document.getElementById('find-input');
 const $findCount   = document.getElementById('find-count');
 
 function openFind() {
+  const ws = window.flolessWorkspaces && window.flolessWorkspaces.findActive();
+  // In Workspaces mode there's nothing to find off the Model step — don't pop a dead overlay.
+  if (document.getElementById('app').classList.contains('mode-workspaces') && !ws) return;
+  $findInput.placeholder = ws ? 'Find in model…' : 'Find agent…';
   $findOverlay.classList.add('show');
   $findInput.value = '';
   $findCount.textContent = '';
@@ -1101,13 +1105,21 @@ function openFind() {
 }
 function closeFind() {
   $findOverlay.classList.remove('show');
+  if (window.flolessWorkspaces && window.flolessWorkspaces.clearFind) window.flolessWorkspaces.clearFind();
   document.querySelectorAll('.agent-card').forEach(c => {
     c.classList.remove('find-dim', 'find-match');
   });
 }
 
 $findInput.addEventListener('input', () => {
-  const q = $findInput.value.toLowerCase().trim();
+  const raw = $findInput.value;
+  const q = raw.toLowerCase().trim();
+  // Workspaces + Model step: search members in the embedded editor, not the canvas.
+  if (window.flolessWorkspaces && window.flolessWorkspaces.findActive()) {
+    const r = window.flolessWorkspaces.find(raw) || { count: 0 };
+    $findCount.textContent = q ? `${r.count} match${r.count === 1 ? '' : 'es'}` : '';
+    return;
+  }
   let matches = 0;
   document.querySelectorAll('.agent-card').forEach(card => {
     if (!q) {

package/dist/web/aware.js

@@ -4655,6 +4655,13 @@
     if (req.type === 'new-workflow') {
       return `Help me build a brand-new floless workflow from scratch, step by step, with your floless-app-new-workflow skill. Ask me what I want it to do, then before writing any node confirm the agents it needs are installed (offer to install a missing one from the catalogue, or to report a not-yet-existing agent as an idea). Author the .flo node by node, verifying each step is correct (plain-English descriptions, validate, compile, a real run), and finish by installing → Compile → ▶ Run so I can see it work and approve.`;
     }
+    if (req.type === 'revision-read') {
+      const snaps = req.snapshots && req.snapshots.length
+        ? `\nRevised drawing${req.snapshots.length > 1 ? 's' : ''} (read these): ${req.snapshots.join(', ')}`
+        : '';
+      const note = req.instruction ? `\nMy note: ${req.instruction}` : '';
+      return `In floless project "${req.project}" (app "${req.appId}"), a REVISED drawing set was attached — re-read it into the SAME project as a new version (do NOT create a new project). Read the drawings per the floless-app-steel-takeoff skill, compose the updated steel.takeoff/v1 contract, then POST /api/projects/${req.project}/revision-read with { contract, message: "<plain-English what changed>", requestId: "${req.id}" }. The server derives the base version + source provenance from this queued request, records a "revision-read" version, and clears the request — do NOT DELETE the request yourself. If you can't read the set, POST /api/projects/${req.project}/revision-requests/${req.id}/fail with { error }.${snaps}${note}`;
+    }
     return '';
   }
 
@@ -4665,6 +4672,7 @@
     tweak: 'floless-app-workflows',
     'ui-customize': 'floless-app-ui',
     rebake: 'floless-app-rebake',
+    'revision-read': 'floless-app-steel-takeoff',
     // The guided-tour ask is picked up by onboarding; the instruction body names the
     // per-app floless-app-<appId> skill for depth when one exists.
     guide: 'floless-app-onboarding',
@@ -4682,10 +4690,15 @@
     if (!body) return '';
     const skill = REQUEST_SKILL[req.type] || 'floless-app-workflows';
     const base = (typeof location !== 'undefined' && location.origin) ? location.origin : 'http://127.0.0.1:4317';
+    // A revision-read is cleared by its own /revision-read POST — a separate DELETE would 404. Every
+    // other type is applied-then-DELETEd by the terminal AI.
+    const clears = req.type === 'revision-read'
+      ? `apply it via the route in the line below (that POST clears this request — do NOT DELETE it separately).`
+      : `apply that request, then DELETE ${base}/api/requests/${req.id}.`;
     const marker =
       `[floless-request type=${req.type} id=${req.id}] — queued from the FloLess Dashboard. ` +
       `Apply it with your ${skill} skill: fetch the authoritative spec from GET ${base}/api/requests, ` +
-      `apply that request, then DELETE ${base}/api/requests/${req.id}. Don't run the line below verbatim.`;
+      `${clears} Don't run the line below verbatim.`;
     return `${marker}\n${body}`;
   }
 
@@ -4764,8 +4777,8 @@
       return;
     }
     $list.innerHTML = pendingRequests.map((r) => {
-      const label = r.type === 'use-template' ? 'template' : r.type === 'ui-customize' ? 'dashboard' : r.type === 'rebake' ? 're-bake' : r.type === 'guide' ? 'guide' : r.type === 'new-workflow' ? 'new workflow' : 'tweak';
-      const badgeCls = r.type === 'tweak' || r.type === 'ui-customize' || r.type === 'rebake' ? 'req-type req-type-tweak' : 'req-type';
+      const label = r.type === 'use-template' ? 'template' : r.type === 'ui-customize' ? 'dashboard' : r.type === 'rebake' ? 're-bake' : r.type === 'revision-read' ? 'revision' : r.type === 'guide' ? 'guide' : r.type === 'new-workflow' ? 'new workflow' : 'tweak';
+      const badgeCls = r.type === 'tweak' || r.type === 'ui-customize' || r.type === 'rebake' || r.type === 'revision-read' ? 'req-type req-type-tweak' : 'req-type';
       const target = r.type === 'tweak' && r.nodeId
         ? ` · node <code>${escapeHtml(r.nodeId)}</code>`
         : r.type === 'rebake' && r.inputName

package/dist/web/index.html

@@ -170,6 +170,15 @@
           <button type="button" data-step="exports" role="tab" aria-selected="false">Exports</button>
           <button type="button" data-step="history" role="tab" aria-selected="false">History</button>
         </div>
+        <!-- Drawings step: a shell toolbar band + revision-read status card ABOVE the filter iframe
+             (chrome around it, never inside — the filter owns its own layout). Shown only on Drawings. -->
+        <div class="ws-drawings-bar" id="ws-drawings-bar" hidden>
+          <span class="ws-drawings-bar-label">Drawing set</span>
+          <span class="ws-drawings-bar-sep"></span>
+          <button type="button" id="ws-attach-revision" class="btn-mini" data-tip="Attach a revised drawing set — your terminal AI reads it into a new version">⤒ Attach revised drawings…</button>
+          <input type="file" id="ws-revision-file" accept=".pdf,image/*" multiple hidden>
+        </div>
+        <div class="ws-revision-card" id="ws-revision-card" hidden></div>
         <!-- Two lazily-srced iframes so switching steps never reloads the editor's 3D state.
              Same-origin like #contract-editor-frame (they call /api/contract directly). -->
         <iframe id="ws-frame-model" class="ws-frame" title="Project model editor" hidden></iframe>

package/dist/web/steel-editor.html

@@ -851,6 +851,7 @@ let dimChain=false, dimChainPrev=null, dimSeq=0;   // chained "continuous" dimen
 let dimSplitMode=false;   // "add split point" mode on a selected dim — each click inserts a point and splits the dim segment under it into two
 let sel3dDimIds=new Set(),dim3dAnchor=null;   // selected 3D dimension ids (multi-select like parts; 3D view highlights them, Delete removes them)
 let selIds=new Set();
+let findHits=new Set();   // Find-in-model highlight (Workspaces Ctrl+F) — kept SEPARATE from selIds so a search never clobbers/drops the user's real selection
 let undo=[], redo=[];
 const byId=id=>P.members.find(m=>m.id===id);
 const selArr=()=>P.members.filter(m=>selIds.has(m.id));
@@ -1420,8 +1421,8 @@ function render(){
  let s=RB64?`<image href="data:image/jpeg;base64,${RB64}" x="${X0}" y="${Y0}" width="${X1-X0}" height="${Y1-Y0}"/>`:'';
  s+=gridSvg();   // structural grid under the linework (members/dims stay on top)
  for(const sg of P.segments) s+=`<line class=seg data-seg="${sg.id}" x1="${sg.a[0]}" y1="${sg.a[1]}" x2="${sg.b[0]}" y2="${sg.b[1]}"/>`;
- for(const m of P.members){const c=colorFor(m.profile);const on=selIds.has(m.id);const g=on?` style="filter:drop-shadow(0 0 3px ${c}) drop-shadow(0 0 8px ${c})"`:'';
-   s+=`<line class="member${m.rfi?' rfi':''}${on?' sel':''}" data-id="${m.id}" x1="${m.wp[0][0]}" y1="${m.wp[0][1]}" x2="${m.wp[1][0]}" y2="${m.wp[1][1]}" stroke="${c}"${g}/>`;}
+ for(const m of P.members){const c=colorFor(m.profile);const sel=selIds.has(m.id);const fh=findHits.has(m.id);const on=sel||fh;const g=on?` style="filter:drop-shadow(0 0 3px ${c}) drop-shadow(0 0 8px ${c})"`:'';
+   s+=`<line class="member${m.rfi?' rfi':''}${sel?' sel':''}${fh?' find-hit':''}" data-id="${m.id}" x1="${m.wp[0][0]}" y1="${m.wp[0][1]}" x2="${m.wp[1][0]}" y2="${m.wp[1][1]}" stroke="${c}"${g}/>`;}
  {const hsel=selArr();if(hsel.length>=1){const HR=epR();for(const sm of hsel)for(let i=0;i<2;i++) s+=`<circle class="handle ${i===0?'ep-start':'ep-end'}" data-mid="${sm.id}" data-h="${i}" cx="${sm.wp[i][0]}" cy="${sm.wp[i][1]}" r="${HR}"/>`;}}  // end 1 (start) yellow, end 2 (end) magenta · shown for every selected member · radius grows with zoom (epR) so it stays visible against the thick line
  if((mode==='add'||(picking&&pickKind==='profile'))&&P.labels) for(const lb of P.labels){const w=Math.max(40,lb.text.length*11);
    s+=`<rect class=lblhot data-prof="${esc(lb.text)}" x="${lb.disp[0]-w/2}" y="${lb.disp[1]-10}" width="${w}" height="20" rx="3"><title>${esc(lb.text)}</title></rect>`;}
@@ -3036,16 +3037,36 @@ const view3dApi={
  onClipModeChange:(m)=>{const b=document.getElementById('m3dClip');if(b){b.classList.toggle('on',!!m);b.textContent=m?'Clip ✕':'Clip ▾';}},  // armed → button fills brand-blue + becomes a cancel target (✕ = cancel)
  onInsertModeChange:(on)=>{const b=document.getElementById('m3dInsert');if(b){b.classList.toggle('on',!!on);b.textContent=on?'✕ Cancel insert':'Insert…';}},  // armed → cancel target
  onInsertPlace:(pick,pending)=>{
-  // Slice B: place an IMPORTED connection — bake a `custom` joint carrying its LOCAL mesh geometry at
-  // the picked point (joint.place); expandCustom re-expands it into the scene as one selectable unit.
-  if(pending&&pending.kind==='connection'&&pending.connection&&Array.isArray(pending.connection.geometry)){
-   const conn=pending.connection;
-   const id='cx'+Date.now().toString(36)+Math.floor(Math.random()*1e4).toString(36);
-   const joint={id,kind:'custom',name:conn.name||'Imported connection',place:pick.point,geometry:conn.geometry,source:'user'};
-   if(pick.anchorId)joint.main=pick.anchorId; // snapped to a member face → record it for the inspector's "on member" line
-   edit(()=>{if(!Array.isArray(C.joints))C.joints=[];C.joints.push(joint);selIds=new Set(conn.geometry.map((g,i)=>id+':'+(g.id||'m'+i)));});
-   toast('Connection “'+(conn.name||'imported')+'” placed'+(pick.anchorId?' on '+pick.anchorId:'')+' — select it to move or replace');
-   return;
+  if(pending&&pending.kind==='connection'&&pending.connection){
+   const conn=pending.connection;const rc=conn.recipe;
+   // Slice C: a RECOGNIZED base plate dropped onto a COLUMN → bake an EDITABLE base-plate recipe joint;
+   // expandBasePlate re-derives it on that column from the fitted params (frame-independent scalars), so
+   // it becomes a first-class parametric connection, not opaque mesh. Needs a column at the pick.
+   const col=(rc&&rc.kind==='base-plate'&&pick.anchorId)?P.members.find(m=>m&&m.id===pick.anchorId&&m.role==='column'):null;
+   if(col){
+    const id='cx'+Date.now().toString(36)+Math.floor(Math.random()*1e4).toString(36);
+    const joint={id,kind:'base-plate',main:col.id,at:'base',params:Object.assign({},rc.params),source:'user'};
+    pendingConnSel=id; // its parts only exist after the 3D rebuild → select the whole connection there
+    // Applying a base plate to a column REPLACES any base plate already on it (a column has one base
+    // plate) — else the two overlap and "edit on member" would target the older joint, not this import.
+    const had=(C.joints||[]).some(x=>x&&x.kind==='base-plate'&&x.main===col.id);
+    edit(()=>{C.joints=(Array.isArray(C.joints)?C.joints:[]).filter(x=>!(x&&x.kind==='base-plate'&&x.main===col.id));C.joints.push(joint);selIds=new Set();});
+    toast((had?'Base plate on '+col.id+' replaced with imported “'+(conn.name||'connection')+'”':'Base plate “'+(conn.name||'imported')+'” applied to '+col.id)+' — edit its parameters on the member');
+    return;
+   }
+   // Slice B: opaque custom mesh — bake at the picked point (joint.place); expandCustom re-expands it into
+   // the scene as one selectable unit. Unrecognized imports, and a recognized base plate NOT dropped on a
+   // column, land here (still faithful geometry) with a hint toward the editable path.
+   if(Array.isArray(conn.geometry)&&conn.geometry.length){
+    const id='cx'+Date.now().toString(36)+Math.floor(Math.random()*1e4).toString(36);
+    const joint={id,kind:'custom',name:conn.name||'Imported connection',place:pick.point,geometry:conn.geometry,source:'user'};
+    if(pick.anchorId)joint.main=pick.anchorId; // snapped to a member face → record it for the inspector's "on member" line
+    edit(()=>{if(!Array.isArray(C.joints))C.joints=[];C.joints.push(joint);selIds=new Set(conn.geometry.map((g,i)=>id+':'+(g.id||'m'+i)));});
+    toast(rc?('Imported “'+(conn.name||'connection')+'” as geometry — drop it on a column to apply it as an editable base plate')
+           :('Connection “'+(conn.name||'imported')+'” placed'+(pick.anchorId?' on '+pick.anchorId:'')+' — select it to move or replace'));
+    return;
+   }
+   toast('That connection has no geometry to place');return;
   }
   if(!pending||!pending.name){toast('Pick a detail to insert first');return;}   // Slice 4: place the queued detail at the pick, select it, record the create intent
   const id='det'+Date.now().toString(36)+Math.floor(Math.random()*1e4).toString(36);const sheet=(P&&P.sheet)||'';
@@ -3058,7 +3079,11 @@ const view3dApi={
 };
 // Re-extrude the 3D model after a structural edit (keeps the camera where it is). Selection-only
 // changes go through render()'s setSelection — only geometry mutations need a rebuild.
-function sync3D(){if(view3d&&view3dReady&&window.Steel3DView){window.Steel3DView.rebuild(false).then(()=>{window.Steel3DView.setSelection(selIds);build3DLegend();panel();}).catch(()=>{});}}  // rebuild also refreshes the legend (an edit may add/remove a profile) + re-renders the inspector so a selection of just-created parts (e.g. a placed custom connection) resolves against the freshly-fetched partsById, not the pre-rebuild stale copy
+let pendingConnSel=null;  // a just-baked connection whose parts exist only AFTER the next rebuild → select the whole thing there (a recognized base-plate import, whose part ids aren't known ahead of expansion)
+function sync3D(){if(view3d&&view3dReady&&window.Steel3DView){window.Steel3DView.rebuild(false).then(()=>{
+  if(pendingConnSel&&window.Steel3DView.selectWholeConn){const c=pendingConnSel;pendingConnSel=null;window.Steel3DView.selectWholeConn(c);}  // whole-connection select (envelope + "Parametric — editable" inspector), same as a 3D click
+  else window.Steel3DView.setSelection(selIds);
+  build3DLegend();panel();}).catch(()=>{pendingConnSel=null;});}}  // rebuild also refreshes the legend (an edit may add/remove a profile) + re-renders the inspector so a selection of just-created parts (e.g. a placed custom connection) resolves against the freshly-fetched partsById, not the pre-rebuild stale copy
 // Insert-a-detail helpers (Slice 4). armInsert queues a detail image + arms the 3D placement pick;
 // detailRequest records a create/modify request on the SAME tweak-contract channel, adding intent+target
 // so the terminal AI knows whether to build a new detail or update a placed one, and where.
@@ -3066,12 +3091,17 @@ function armInsert(name){if(!name)return;const raw=(C.custom_details||{})[name];
   if(!view3d){toast('Switch to the 3D view to place a detail');return;}
   window.Steel3DView.setInsertMode(true,{name});
   toast('Click a beam or the model to place “'+name+'” — Esc to cancel');}
-// Slice B: arm the crosshair to place an IMPORTED connection (its LOCAL mesh geometry rides on the
-// pending object; onInsertPlace bakes the custom joint where the user clicks). 3D view only.
+// Slice B/C: arm the crosshair to place an IMPORTED connection (its LOCAL mesh geometry + optional
+// recognized recipe ride on the pending object; onInsertPlace bakes a base-plate recipe on a column, or
+// the custom mesh where the user clicks). 3D view only.
 function armConnectionInsert(connection){if(!connection||!Array.isArray(connection.geometry)||!connection.geometry.length){toast('That connection has no geometry to place');return;}
   if(!view3d){toast('Switch to the 3D view to place a connection');return;}
   window.Steel3DView.setInsertMode(true,{kind:'connection',connection});
-  toast('Click in the model to place “'+(connection.name||'connection')+'” — Esc to cancel');}
+  const nm=connection.name||'connection';
+  // Recognized base plate → tell the user to target a column (the editable path); else the generic place hint.
+  const recognized=connection.recipe&&connection.recipe.kind==='base-plate';
+  toast(recognized?('Click a column to place “'+nm+'” as an editable base plate — Esc to cancel')
+                  :('Click in the model to place “'+nm+'” — Esc to cancel'));}
 async function detailRequest(intent,place,note){
   // flushContract PUTs C to the server so the terminal AI reads the latest contract — but it clears the
   // debounced autosave (saveT) WITHOUT writing localStorage, which would drop the just-placed detail from
@@ -3767,13 +3797,40 @@ function rfiReason(m){if(!m.profile)return 'No profile assigned';
 function zoomToMember(m){const a=m.wp[0],b=m.wp[1],w=Math.abs(a[0]-b[0])||40,h=Math.abs(a[1]-b[1])||40;
  applyZoom(Math.max(.3,Math.min(2.5,Math.min(stage.clientWidth/(w*2.2),stage.clientHeight/(h*2.2)))));
  const cx=(a[0]+b[0])/2,cy=(a[1]+b[1])/2;stage.scrollLeft=(cx-X0)*zoom-stage.clientWidth/2;stage.scrollTop=(cy-Y0)*zoom-stage.clientHeight/2;}
-// Frame the whole current selection (Tekla "Zoom selected"); falls back to fit-all when nothing's picked — mirrors the 3D view's frameSelection().
-function zoomToSelection(){const arr=selArr();if(!arr.length){fitToWindow();return;}
+// ── Find in model (Workspaces Ctrl+F) ──────────────────────────────────────────
+// Match a member's id/mark + profile (case-insensitive substring) across ALL plans, switch to the
+// first plan with a hit, HIGHLIGHT those hits (via findHits — a set kept SEPARATE from selIds so a
+// same-plan search never touches the user's real selection; a cross-plan hit switches sheets via
+// setPlan, which resets selection like any plan change), and frame them. Returns {count,shown}
+// for the shell's find overlay. Called cross-iframe by workspaces.js via the same-origin
+// contentWindow, like flushContract(). clearFind() drops the find highlight only (leaves selection).
+function _findMatch(m, q){ return [m.id, m.mark, m.profile].filter(Boolean).join(' ').toLowerCase().includes(q); }
+function findMember(query){
+  const q = String(query == null ? '' : query).toLowerCase().trim();
+  if(!q){ clearFind(); return { count: 0, shown: 0 }; }
+  let total = 0, firstPlan = -1, firstHits = [];
+  (C.plans || []).forEach((pl, pi) => {
+    const ids = (pl.members || []).filter((m) => _findMatch(m, q)).map((m) => m.id);
+    total += ids.length;
+    if(ids.length && firstPlan < 0){ firstPlan = pi; firstHits = ids; }
+  });
+  if(firstPlan < 0){ findHits = new Set(); render(); return { count: 0, shown: 0 }; }
+  if(firstPlan !== C.active) setPlan(firstPlan);
+  findHits = new Set(firstHits);
+  render(); zoomToMembers(P.members.filter((m) => findHits.has(m.id)));
+  return { count: total, shown: firstHits.length };
+}
+function clearFind(){ if(findHits.size){ findHits = new Set(); render(); } }
+window.findMember = findMember; window.clearFind = clearFind; // expose to the shell, like window.flushContract (top-level fns aren't reliably on window here)
+// Frame an arbitrary set of members (bbox → fit); falls back to fit-all when empty. Shared by
+// zoomToSelection (Tekla "Zoom selected") and Find-in-model — mirrors the 3D view's frameSelection().
+function zoomToMembers(arr){if(!arr.length){fitToWindow();return;}
  let x0=Infinity,y0=Infinity,x1=-Infinity,y1=-Infinity;
  for(const m of arr)for(const p of m.wp){if(p[0]<x0)x0=p[0];if(p[0]>x1)x1=p[0];if(p[1]<y0)y0=p[1];if(p[1]>y1)y1=p[1];}
  const w=Math.max(x1-x0,40),h=Math.max(y1-y0,40);
  applyZoom(Math.min(stage.clientWidth/(w*1.35),stage.clientHeight/(h*1.35)));
  const cx=(x0+x1)/2,cy=(y0+y1)/2;stage.scrollLeft=(cx-X0)*zoom-stage.clientWidth/2;stage.scrollTop=(cy-Y0)*zoom-stage.clientHeight/2;}
+function zoomToSelection(){zoomToMembers(selArr());}
 function openRFI(){const g=document.getElementById('rfiGrid');const list=rfiList();
  g.innerHTML=list.length?('<div class=hint style="margin-bottom:10px">'+list.length+' member'+(list.length>1?'s':'')+' have no resolved AISC size, so their weight is excluded from the BOM. Assign a profile to clear it — for <b>MF/BF</b> marks use the <b>Frames</b> schedule. Edits here update the contract.</div><table class=ftab><thead><tr><th>#</th><th>Profile / mark</th><th>Role</th><th>Length</th><th>Why it’s flagged</th><th></th></tr></thead><tbody>'+
    list.map((m,i)=>{ensureMeta(m);const L=_lenFt(m).toFixed(1);
@@ -4037,7 +4094,7 @@ function setPlan(i){C.active=i;P=C.plans[i];
      scheduleSave();setTimeout(()=>toast('Auto-removed '+red.size+' duplicate member'+(red.size>1?'s':'')),60);}}
  profs=[...new Set([...P.members.map(m=>m.profile), ...Object.keys(WT)])].sort();
  undo=P.undo||(P.undo=[]);redo=P.redo||(P.redo=[]);
- selIds=new Set();picking=false;pickKind='profile';pickEnd=null;mode='sel';geoMode=null;
+ selIds=new Set();findHits=new Set();picking=false;pickKind='profile';pickEnd=null;mode='sel';geoMode=null;   // findHits resets per plan like selIds — a stale Find highlight must not bleed onto another sheet via a colliding member id
  dimMode=false;dimChain=false;dimSplitMode=false;selDimIds=new Set();setDimMode();   // Dimension tool resets per plan (incl. chain + split); setDimMode syncs the button/body.dimon classes + clears any draft/preview/chain (dimsVisible persists across plans)
  if(gridMode||gridPick){gridMode=false;gridPick=false;document.body.classList.remove('gridpick');}   // grid panel/pick-origin disarm per plan like the other takeover tools (a leaked pick would set the origin in the WRONG sheet's display space)
  csaxisMode=false;setCsMode();                     // set-axes tool resets per plan; P.frame itself is per-plan data (persisted), so it stays

package/dist/web/workspaces.js

@@ -36,6 +36,10 @@
     model: document.getElementById('ws-frame-model'),
     drawings: document.getElementById('ws-frame-drawings'),
   };
+  const $drawingsBar = document.getElementById('ws-drawings-bar');
+  const $revisionCard = document.getElementById('ws-revision-card');
+  const $revisionFile = document.getElementById('ws-revision-file');
+  let currentStep = 'model';
 
   // The Exports step's cards. `file:true` = writes a file on disk (shown with a "✓ exported HH:MM"
   // line + ⧉ Open / ▤ Reveal); `open:false` (IFC) = reveal-only (no OS default app for a .ifc).
@@ -171,6 +175,7 @@
     if (!p) { try { p = (await api('/api/projects')).projects.find((x) => x.id === id); } catch { /* fall through */ } }
     if (!p) { showToast('Project not found — it may have been archived.', 'warn'); return loadProjects(); }
     current = p;
+    lastRevState = 'none'; stopRevisionPoll(); // fresh project — drop any prior revision-poll state
     $projName.textContent = p.name;
     $crumbName.textContent = p.name;
     $status.textContent = p.app;
@@ -184,10 +189,11 @@
     setStep('model');
     applyMode();
   }
-  function closeProject() { current = null; closeProjMenu(); applyMode(); }
+  function closeProject() { current = null; stopRevisionPoll(); lastRevState = 'none'; $revisionCard.hidden = true; closeProjMenu(); applyMode(); }
   document.getElementById('ws-back').addEventListener('click', closeProject);
 
   function setStep(s) {
+    currentStep = s;
     $stepTabs.querySelectorAll('button').forEach((b) => {
       const on = b.dataset.step === s;
       b.classList.toggle('active', on);
@@ -198,6 +204,8 @@
       f.hidden = !show;
       if (show && !f.dataset.loaded) { f.src = f.dataset.want; f.dataset.loaded = '1'; }
     }
+    $drawingsBar.hidden = s !== 'drawings';
+    renderRevisionCard(); // reflect any pending/failed revision read (card shows only on the Drawings step)
     // Exports is a shell-rendered pane (not an iframe): show/hide + (re)paint on open.
     const showExports = s === 'exports';
     $wsExports.hidden = !showExports;
@@ -240,6 +248,43 @@
   }
   document.getElementById('ws-approve').addEventListener('click', approveProject);
 
+  // ── Find in model bridge (app.js Ctrl+F delegates here in Workspaces mode) ──────
+  // Active only when a project is open on the Model step, the editor iframe is loaded and exposes
+  // findMember(), and there's no pending "AI updated — reload" banner (searching a stale in-memory
+  // model would mislead). Same-origin contentWindow call, like the Approve flush above.
+  function wsFindActive() {
+    if (!$app.classList.contains('mode-workspaces')) return false;
+    if (!current || frames.model.hidden) return false; // Model step must be showing
+    const w = frames.model.contentWindow;
+    if (!w || typeof w.findMember !== 'function') return false;
+    try { if (w.document.getElementById('aiUpdateBanner')) return false; } catch { return false; }
+    return true;
+  }
+  function wsFind(q) {
+    try { const w = frames.model.contentWindow; if (w && typeof w.findMember === 'function') return w.findMember(q); } catch { /* iframe reloaded between findActive() and here */ }
+    return { count: 0 };
+  }
+  function wsClearFind() {
+    const w = frames.model && frames.model.contentWindow;
+    if (w && typeof w.clearFind === 'function') { try { w.clearFind(); } catch { /* iframe gone */ } }
+  }
+  // While focus is inside the editor iframe (the usual case on the Model step), the parent's Ctrl+F
+  // handler never sees the key — so the shell forwards Cmd/Ctrl+F from the same-origin editor up to
+  // the global openFind. Re-wired on every iframe (re)load; each load is a fresh contentWindow, so
+  // the listeners don't stack.
+  frames.model.addEventListener('load', () => {
+    try {
+      frames.model.contentWindow.addEventListener('keydown', (e) => {
+        if ((e.ctrlKey || e.metaKey) && !e.shiftKey && (e.key === 'f' || e.key === 'F')) {
+          e.preventDefault();
+          if (typeof window.openFind === 'function') window.openFind();
+        }
+      });
+    } catch { /* not-yet-loaded / cross-origin */ }
+  });
+  // (find methods are exposed on the canonical window.flolessWorkspaces export below — a separate
+  //  assignment here would be clobbered by that later `= { setMode, … }`.)
+
   // ── Exports step ──────────────────────────────────────────────────────────────
   const hhmm = (iso) => {
     const d = new Date(iso);
@@ -367,6 +412,141 @@
     if (rev) { fileAction('/api/reveal', rev.dataset.reveal, 'Couldn’t reveal the file'); return; }
   });
 
+  // ── Revisions: attach a revised drawing set → queue a compose-time read (Slice 4b) ──
+  // The browser records intent + files and QUEUES the read; the terminal AI reads and commits a
+  // `revision-read` version. The pending/failed card is Drawings-scoped (proximity to the action; the
+  // footer Requests popover surfaces it globally). A self-contained poll resolves it — the shell has
+  // no SSE hook — and refreshes History on completion. Cards are DOM-built (textContent, never
+  // innerHTML) so an AI-supplied error string can never reach the DOM as markup.
+  let lastRevState = 'none';
+  let revBaseVersion = 0; // the ledger head captured at attach — success = the head advances past it
+  let revCardReq = null;
+  let revisionPoll = null;
+  function stopRevisionPoll() { if (revisionPoll) { clearInterval(revisionPoll); revisionPoll = null; } }
+  function startRevisionPoll() {
+    stopRevisionPoll();
+    revisionPoll = setInterval(() => { if (current) renderRevisionCard(); else stopRevisionPoll(); }, 3000);
+  }
+  const revEl = (tag, cls, text) => {
+    const e = document.createElement(tag);
+    if (cls) e.className = cls;
+    if (text != null) e.textContent = text;
+    return e;
+  };
+
+  function readFileAsSnapshot(file) {
+    return new Promise((resolve, reject) => {
+      const r = new FileReader();
+      r.onload = () => resolve({ name: file.name, dataUrl: String(r.result) });
+      r.onerror = () => reject(new Error('read failed'));
+      r.readAsDataURL(file);
+    });
+  }
+
+  async function attachRevision(files) {
+    const proj = current; // capture — the user may switch projects during the async file reads / POST
+    if (!proj || !files.length) return;
+    let snapshots;
+    try { snapshots = await Promise.all(files.map(readFileAsSnapshot)); }
+    catch { showToast('Could not read the selected files', 'warn'); return; }
+    if (current !== proj) return; // switched projects mid-read — abandon rather than queue against the wrong one
+    let res;
+    try {
+      res = await api(`/api/projects/${encodeURIComponent(proj.id)}/revision-requests`, {
+        method: 'POST', body: JSON.stringify({ appId: proj.app, snapshots }),
+      });
+    } catch (err) { showToast('Attach failed: ' + ((err && err.message) || err), 'warn'); return; }
+    const req = res && res.request;
+    // Copy the paste-ready instruction so the user can hand it to their terminal AI (best-effort).
+    if (req && bridge.markedInstruction && bridge.copyToClipboard) {
+      try { await bridge.copyToClipboard(bridge.markedInstruction(req)); } catch { /* clipboard blocked */ }
+    }
+    if (bridge.loadRequests) bridge.loadRequests().catch(() => {}); // refresh the footer Requests popover
+    if (current !== proj) return; // switched away while posting — don't drive the wrong project's card/poll
+    showToast(`Revised set queued — ${files.length} file${files.length > 1 ? 's' : ''} for your terminal AI`, 'ok');
+    revBaseVersion = (req && typeof req.baseVersion === 'number') ? req.baseVersion : 0;
+    lastRevState = 'pending';
+    startRevisionPoll();
+    renderRevisionCard();
+  }
+
+  document.getElementById('ws-attach-revision').addEventListener('click', () => $revisionFile.click());
+  $revisionFile.addEventListener('change', () => {
+    const files = [...($revisionFile.files || [])];
+    $revisionFile.value = ''; // clear so re-picking the same file re-fires change
+    attachRevision(files);
+  });
+
+  function buildPendingCard(req) {
+    const n = (req.sourceRefs && req.sourceRefs.length) || (req.snapshots && req.snapshots.length) || 1;
+    const spin = revEl('span', 'wrc-spin'); spin.setAttribute('aria-hidden', 'true');
+    const txt = revEl('span', 'wrc-text');
+    txt.appendChild(revEl('b', null, 'Reading the revised set…'));
+    txt.appendChild(document.createTextNode(` ${n} file${n > 1 ? 's' : ''} queued for your terminal AI — paste the copied instruction there, or say “apply my floless request”.`));
+    const copy = revEl('button', 'btn-mini', '⧉ Copy');
+    copy.type = 'button'; copy.dataset.revcopy = ''; copy.setAttribute('data-tip', 'Copy the instruction again');
+    return [spin, txt, copy];
+  }
+  function buildFailedCard(req) {
+    const ico = revEl('span', 'wrc-err-ico', '⚠'); ico.setAttribute('aria-hidden', 'true');
+    const txt = revEl('span', 'wrc-text');
+    txt.appendChild(revEl('b', null, 'The read failed.'));
+    txt.appendChild(document.createTextNode(' '));
+    txt.appendChild(revEl('span', 'wrc-err-detail', req.error || 'The read could not be completed.'));
+    txt.appendChild(document.createTextNode(' Attach the set again to retry.'));
+    const actions = revEl('span', 'wrc-actions');
+    const dismiss = revEl('button', 'btn-mini', 'Dismiss'); dismiss.type = 'button'; dismiss.dataset.revdismiss = '';
+    actions.appendChild(dismiss);
+    return [ico, txt, actions];
+  }
+
+  async function renderRevisionCard() {
+    if (!current) { $revisionCard.hidden = true; return; }
+    let reqs = [];
+    try { const b = await api('/api/requests'); reqs = Array.isArray(b) ? b : (b.requests || []); } catch { return; }
+    const mine = reqs.filter((r) => r && r.type === 'revision-read' && r.project === current.id);
+    const failed = mine.find((r) => r.status === 'failed');
+    const pending = mine.find((r) => r.status === 'pending');
+    const state = failed ? 'failed' : pending ? 'pending' : 'none';
+    // Was pending, now nothing in flight. Confirm a NEW version actually committed (the head advanced
+    // past the attach baseVersion) before celebrating — a bare request DELETE (Dismiss / footer-clear)
+    // must NOT show a false "complete" toast or re-lock exports.
+    if (lastRevState === 'pending' && state === 'none') {
+      let vr;
+      try { vr = await api(`/api/projects/${encodeURIComponent(current.id)}/versions`); }
+      catch { return; } // transient — leave lastRevState 'pending'; the poll retries next tick
+      const tip = (vr.versions || [])[0];
+      if (tip && tip.kind === 'revision-read' && tip.n > revBaseVersion) {
+        current.approvedAt = vr.approvedAt || undefined; // the AI read cleared the sign-off (exports re-lock)
+        if (!$wsHistory.hidden) renderHistory();
+        showToast('Revision read complete — a new version is on History', 'ok');
+      }
+    }
+    lastRevState = state;
+    if (state === 'none') { stopRevisionPoll(); $revisionCard.hidden = true; $revisionCard.replaceChildren(); return; }
+    if (state === 'failed') stopRevisionPoll();
+    else if (!revisionPoll) startRevisionPoll(); // a pending read seen on load → keep it fresh
+    if (currentStep !== 'drawings') { $revisionCard.hidden = true; return; } // card is Drawings-scoped
+    revCardReq = failed || pending;
+    $revisionCard.className = 'ws-revision-card ' + (state === 'failed' ? 'state-failed' : 'state-pending');
+    $revisionCard.replaceChildren(...(state === 'failed' ? buildFailedCard(failed) : buildPendingCard(pending)));
+    $revisionCard.hidden = false;
+  }
+
+  $revisionCard.addEventListener('click', async (e) => {
+    const req = revCardReq;
+    if (!req) return;
+    if (e.target.closest('[data-revcopy]') && bridge.markedInstruction && bridge.copyToClipboard) {
+      const ok = await bridge.copyToClipboard(bridge.markedInstruction(req));
+      showToast(ok ? 'Instruction copied' : 'Copy blocked — use the Requests panel', ok ? 'ok' : 'warn');
+    } else if (e.target.closest('[data-revdismiss]')) {
+      try { await api(`/api/requests/${encodeURIComponent(req.id)}`, { method: 'DELETE' }); } catch { /* already gone */ }
+      lastRevState = 'none';
+      if (bridge.loadRequests) bridge.loadRequests().catch(() => {});
+      renderRevisionCard();
+    }
+  });
+
   // ── History step ────────────────────────────────────────────────────────────────
   // The project's version ledger. A version = a commit (Approve = Model gate, Rollback = unsigned).
   // The draft contract is the working tree; an unapproved draft shows the working-copy banner.
@@ -380,10 +560,13 @@
     author === 'You'
       ? '<span class="avatar you">YOU</span>'
       : `<span class="avatar ai">${escapeHtml((author || '?').replace(/[^A-Za-z0-9]/g, '').slice(0, 2).toUpperCase() || 'AI')}</span>`;
-  const gateBadge = (gate) =>
-    gate === 'model'
-      ? '<span class="gate-badge model" data-tip="Model gate — the geometry was signed off">Model</span>'
-      : '<span class="gate-badge" data-tip="Unsigned — a working-tree restore, not a sign-off">unsigned</span>';
+  const gateBadge = (gate, kind) => {
+    if (gate === 'model')
+      return '<span class="gate-badge model" data-tip="Model gate — the geometry was signed off">Model</span>';
+    if (kind === 'revision-read')
+      return '<span class="gate-badge ai-read" data-tip="AI read — the terminal AI composed this version from a revised drawing set; Approve to sign it off">AI read</span>';
+    return '<span class="gate-badge" data-tip="Unsigned — a working-tree restore, not a sign-off">unsigned</span>';
+  };
 
   let versions = []; // last-rendered ledger (newest first)
 
@@ -396,7 +579,7 @@
       `<td><span class="ver${v.current ? ' cur' : ''}">v${escapeHtml(String(v.n))}</span></td>` +
       `<td class="htime">${escapeHtml(histWhen(v.ts))}</td>` +
       `<td><span class="hby">${avatarFor(v.author)}${escapeHtml(v.author)}</span></td>` +
-      `<td>${gateBadge(v.gate)}</td>` +
+      `<td>${gateBadge(v.gate, v.kind)}</td>` +
       `<td class="change">${escapeHtml(v.message)}</td>` +
       `<td>${action}</td></tr>`;
   }
@@ -430,9 +613,13 @@
     }
     // Working copy = the draft; when it isn't signed off (approvedAt cleared by an edit or a
     // rollback) surface it honestly ABOVE the table (not as a fake row) and name the Exports lock.
+    const headKind = rows.length && rows[0].current ? rows[0].kind : undefined;
     const working = !approvedAt
-      ? '<div class="hist-working">● <b>Working copy isn’t signed off.</b> ' +
-        '<button type="button" id="hist-approve">Approve</button> to sign off this version. Exports stay locked until you do.</div>'
+      ? (headKind === 'revision-read'
+          ? '<div class="hist-working">● <b>The AI read a revised drawing set — review it before signing.</b> ' +
+            'Open <b>Model</b> to check the change, then <button type="button" id="hist-approve">Approve</button> to sign off. Exports stay locked until you do.</div>'
+          : '<div class="hist-working">● <b>Working copy isn’t signed off.</b> ' +
+            '<button type="button" id="hist-approve">Approve</button> to sign off this version. Exports stay locked until you do.</div>')
       : '';
     $wsHistory.innerHTML =
       '<div class="hist-note">Every <b>Approve</b> and <b>Rollback</b> records a version. Rollback is non-destructive — it restores a version as a <i>new</i> one.</div>' +
@@ -553,6 +740,6 @@
     loadProjects();
   });
 
-  window.flolessWorkspaces = { setMode, refresh: loadProjects };
+  window.flolessWorkspaces = { setMode, refresh: loadProjects, findActive: wsFindActive, find: wsFind, clearFind: wsClearFind };
   applyMode(); // restore persisted mode immediately (matches panels.js applyView timing)
 })();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@floless/app",
-  "version": "0.75.0",
+  "version": "0.76.0",
   "type": "module",
   "description": "Thin localhost host for floless.app — serves web/ and shells the aware CLI. No engine, no LLM.",
   "bin": {