@floless/app 0.83.0 → 0.85.0

package/dist/web/workspaces.js

@@ -19,6 +19,9 @@
     if (!res.ok || body.ok === false) { const e = new Error(body.error || `HTTP ${res.status}`); e.body = body; throw e; }
     return body;
   });
+  // Product-analytics seam (analytics.js, loaded first). A no-op until PostHog is configured;
+  // itself already swallows errors, but guard the lookup too so a missing global never throws.
+  const track = (name, props) => { try { if (window.trackEvent) window.trackEvent(name, props || {}); } catch { /* analytics never breaks UX */ } };
 
   const $app = document.getElementById('app');
   const $switch = document.getElementById('mode-switch');
@@ -39,17 +42,9 @@
   const $drawingsBar = document.getElementById('ws-drawings-bar');
   const $revisionCard = document.getElementById('ws-revision-card');
   const $revisionFile = document.getElementById('ws-revision-file');
+  const $sourcePlaceholder = document.getElementById('ws-source-placeholder'); // shown for a filter-less Source step
   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).
-  // Tekla is an ACTION (host mutation, no file). `kind` matches the server's export route + listing.
-  const EXPORT_CARDS = [
-    { kind: 'bom-csv',  ico: '▤', name: 'Bill of materials', fmt: 'CSV',            verb: 'Export CSV',   file: true,  open: true  },
-    { kind: 'bom-xlsx', ico: '▦', name: 'Bill of materials', fmt: 'XLSX',           verb: 'Export Excel', file: true,  open: true  },
-    { kind: 'ifc',      ico: '◈', name: 'Model',             fmt: 'IFC4',           verb: 'Export IFC',   file: true,  open: false },
-    { kind: 'tekla',    ico: '◧', name: 'Tekla',             fmt: '.ifc → Open API', verb: 'Send to Tekla', file: false },
-  ];
   let exportState = null; // kind → { path, exportedAt } after a successful list; null = unknown/failed
   if (!$switch || !$landing || !$app) return; // markup absent — nothing to wire
 
@@ -58,12 +53,86 @@
   const closeProjMenu = () => { $projMenu.hidden = true; $projMenu.classList.remove('show'); };
 
   const LS_MODE = 'floless:mode';
-  const WORKSPACE_APP = 'steel-model'; // slice 1: the one workspace app; a manifest flag generalizes this in slice 5
+  // Per-app Workspaces presentation. The flag (floless.workspace, surfaced on /api/apps) says WHICH
+  // apps are workspaces; this map says HOW to render each (presentation is ours — spec §3.2). Two
+  // first-party apps today; promote to a .flo-declared descriptor when a user-authored one appears.
+  // NB: both apps keep the SAME data-step keys (drawings/model/exports/history) so setStep() and the
+  // frame slots are unchanged — only the first two LABELS and which HTML each frame loads differ.
+  //
+  // `exports`: the Exports-step cards for the app. `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). Tekla is an ACTION (host mutation, no file). `kind` matches the server's export route
+  // + listing (projectExportFiles). renderExports()/exportUrl() read wsApp().exports — never a global.
+  const WORKSPACE_APPS = {
+    'steel-model': {
+      seed: 'takeoff',                       // "+ Import the current takeoff"
+      editor: '/steel-editor.html',
+      filter: '/steel-filter.html',
+      steps: [
+        { key: 'drawings', label: 'Drawings' },
+        { key: 'model',    label: 'Model'    },
+        { key: 'exports',  label: 'Exports'  },
+        { key: 'history',  label: 'History'  },
+      ],
+      diff: true,                            // steel semantic diff expander
+      exports: [
+        { kind: 'bom-csv',  ico: '▤', name: 'Bill of materials', fmt: 'CSV',             verb: 'Export CSV',    file: true,  open: true  },
+        { kind: 'bom-xlsx', ico: '▦', name: 'Bill of materials', fmt: 'XLSX',            verb: 'Export Excel',  file: true,  open: true  },
+        { kind: 'ifc',      ico: '◈', name: 'Model',             fmt: 'IFC4',            verb: 'Export IFC',    file: true,  open: false },
+        { kind: 'tekla',    ico: '◧', name: 'Tekla',             fmt: '.ifc → Open API', verb: 'Send to Tekla', file: false },
+      ],
+    },
+    vectorize: {
+      seed: 'drawing',                       // drop-a-drawing (Task 6)
+      editor: '/vector-editor.html',
+      filter: null,                          // no filter step — Source shows a lightweight placeholder
+      steps: [
+        { key: 'drawings', label: 'Source'  }, // reuse the 'drawings' frame slot; label "Source"
+        { key: 'model',    label: 'Vectors' }, // reuse the 'model' frame slot; label "Vectors"
+        { key: 'exports',  label: 'Exports' },
+        { key: 'history',  label: 'History' },
+      ],
+      diff: false,
+      exports: [
+        { kind: 'svg', ico: '▨', name: 'Vectors', fmt: 'SVG', verb: 'Export SVG', file: true, open: true },
+      ],
+    },
+  };
+  const wsApp = () => (current ? WORKSPACE_APPS[current.app] : null);
   let mode = 'workflows';
   try { if (localStorage.getItem(LS_MODE) === 'workspaces') mode = 'workspaces'; } catch { /* private mode */ }
   let projects = [];
+  // Installed workspace apps, in descriptor order. Populated from /api/apps in loadProjects():
+  // the set = apps flagged workspace===true that ALSO have a WORKSPACE_APPS descriptor (an app
+  // flagged workspace with no descriptor is skipped with a console note — never a broken open).
+  // Drives the per-app create cards. Falls back to the descriptor keys if /api/apps can't be read.
+  let wsAppIds = Object.keys(WORKSPACE_APPS);
   let current = null; // the open project (null = landing)
 
+  // The open app's visible label for a step key (Model→"Model" for steel, "Vectors" for vectorize) —
+  // so shared chrome (banners, prompts) names the app's OWN step, never hard-coded steel vocabulary.
+  // Falls back to a capitalized key if the descriptor is missing a step.
+  const stepLabel = (key) => {
+    const d = wsApp();
+    const st = d && d.steps.find((s) => s.key === key);
+    return (st && st.label) || (key.charAt(0).toUpperCase() + key.slice(1));
+  };
+
+  // ── Workspaces guide beacon (aware.js owns #guide-beacon; we own project state) ──────
+  // The document-lifecycle guide (drop → review → approve → export) is for the drop-a-drawing
+  // DOCUMENT archetype (vectorize today, `seed:'drawing'`), not the pipeline-import archetype
+  // (steel `seed:'takeoff'`, which already onboards via the Workflows beacon). Hand aware.js a
+  // small snapshot of the open project's lifecycle state; it repaints the shared beacon/modal.
+  const wsHasDocGuide = () => { const d = wsApp(); return !!(d && d.seed === 'drawing'); };
+  function syncWorkspaceGuide() {
+    if (!bridge.setWorkspaceGuide) return; // older bridge — no-op (beacon simply stays hidden)
+    if (!current || !wsHasDocGuide()) { bridge.clearWorkspaceGuide && bridge.clearWorkspaceGuide(); return; }
+    // `exported` = an SVG export file exists (from the last export listing); best-known from
+    // exportState, which renderExports() populates. Unknown before Exports is opened → false.
+    const exported = !!(exportState && exportState.svg && exportState.svg.exportedAt);
+    bridge.setWorkspaceGuide({ app: current.app, name: current.name, approved: !!current.approvedAt, exported });
+  }
+
   // ── mode ────────────────────────────────────────────────────────────────────
   function applyMode() {
     const ws = mode === 'workspaces';
@@ -78,11 +147,20 @@
     $spine.hidden = !ws || !current;
     if (!ws && !$projMenu.hidden) closeProjMenu();
     if (ws && !current) loadProjects();
+    // Keep the shared guide beacon in step with mode: in Workflows mode (or the Workspaces
+    // landing) it must NOT show a workspace guide — clear it so aware.js reverts to the
+    // workflow beacon; in a Workspaces project it points at that project's lifecycle.
+    if (!ws || !current) { if (bridge.clearWorkspaceGuide) bridge.clearWorkspaceGuide(); }
+    else syncWorkspaceGuide();
   }
   function setMode(m) {
-    mode = m === 'workspaces' ? 'workspaces' : 'workflows';
+    const next = m === 'workspaces' ? 'workspaces' : 'workflows';
+    const changed = next !== mode;
+    mode = next;
     try { localStorage.setItem(LS_MODE, mode); } catch { /* private mode */ }
     applyMode();
+    // Real user intent: a mode toggle (not the boot/render applyMode). Only on an actual change.
+    if (changed) track('workspaces_mode_switched', { mode });
   }
   $switch.addEventListener('click', (e) => {
     const b = e.target.closest('button[data-mode]');
@@ -112,6 +190,25 @@
     // (the empty-state CTA would be a lie: "no projects yet" when the truth is "load failed").
     try { ({ projects } = await api('/api/projects')); }
     catch (err) { projects = []; showToast('Couldn’t load projects: ' + (err && err.message || err), 'warn'); }
+    // Which workspace apps to offer a create card for: those flagged workspace===true on /api/apps
+    // that we ALSO know how to render (have a WORKSPACE_APPS descriptor). Keep descriptor order for a
+    // stable card order. A load failure leaves wsAppIds at its descriptor-key fallback (still usable).
+    try {
+      const { apps } = await api('/api/apps');
+      const flagged = new Set((apps || []).filter((a) => a && a.workspace === true).map((a) => a.id));
+      wsAppIds = Object.keys(WORKSPACE_APPS).filter((id) => flagged.has(id));
+      // Hardening: /api/apps loaded but flagged NONE of our known workspace apps (a transient
+      // appWorkspace read blip returning false for all). Rather than render zero create cards, fall
+      // back to the descriptor keys — the same usable default a full /api/apps failure lands on.
+      if (wsAppIds.length === 0 && Object.keys(WORKSPACE_APPS).length > 0) {
+        wsAppIds = Object.keys(WORKSPACE_APPS);
+      }
+      for (const a of apps || []) {
+        if (a && a.workspace === true && !WORKSPACE_APPS[a.id]) {
+          console.warn(`[workspaces] app "${a.id}" is flagged workspace but has no client descriptor — skipping its create card`);
+        }
+      }
+    } catch { /* keep the descriptor-key fallback — the create cards still work */ }
     renderLanding();
   }
 
@@ -127,12 +224,32 @@
         `<button type="button" class="ws-kebab" data-kebab="${escapeAttr(p.id)}" aria-label="Project actions" data-tip="Rename · Duplicate · Archive">⋯</button>` +
         `</span></div>`;
     }
-    // Slice-1 creation path: seed a project from the app's current takeoff. The
-    // compose-time "read a drawing set" flow is Slice 4 — this card is honest about that.
-    html += `<button type="button" class="ws-seed" id="ws-seed">` +
-      `<span class="plus">+</span><span>Import the current ${escapeHtml(WORKSPACE_APP)} takeoff as a project</span></button>`;
+    // One create card per installed workspace app, driven by its descriptor's seed behavior:
+    //  • seed:'takeoff' (steel-model) — click-to-import the app's current takeoff (Slice-1 flow, unchanged).
+    //  • seed:'drawing'  (vectorize)  — a drop/pick affordance that starts a project from a dropped file.
+    for (const id of wsAppIds) {
+      const d = WORKSPACE_APPS[id];
+      if (!d) continue;
+      if (d.seed === 'drawing') {
+        html += `<button type="button" class="ws-seed ws-seed-drop" data-seed-app="${escapeAttr(id)}" data-seed-drop="${escapeAttr(id)}">` +
+          `<span class="plus">+</span>` +
+          `<span class="ws-seed-headline">Drop a drawing to start a new Vectorize project</span>` +
+          `<span class="ws-seed-sub">PDF or image — vectors come out editable, ready to export as SVG.</span>` +
+          `</button>`;
+      } else {
+        html += `<button type="button" class="ws-seed" data-seed-app="${escapeAttr(id)}">` +
+          `<span class="plus">+</span><span>Import the current ${escapeHtml(id)} takeoff as a project</span></button>`;
+      }
+    }
     html += `</div>`;
-    if (!projects.length) html += `<div class="ws-empty-note">No projects yet — import your current takeoff above, or ask your terminal AI to read a drawing set.</div>`;
+    // Empty-note copy adapts to which create affordances are on screen: a vectorize card means the
+    // user can drop a drawing right above; otherwise it's the steel import line.
+    if (!projects.length) {
+      const hasDrawingSeed = wsAppIds.some((id) => WORKSPACE_APPS[id] && WORKSPACE_APPS[id].seed === 'drawing');
+      html += hasDrawingSeed
+        ? `<div class="ws-empty-note">No projects yet — drop a drawing above, or ask your terminal AI to vectorize a drawing set.</div>`
+        : `<div class="ws-empty-note">No projects yet — import your current takeoff above, or ask your terminal AI to read a drawing set.</div>`;
+    }
     $landing.innerHTML = html;
   }
 
@@ -141,7 +258,13 @@
     if (kebab) { e.stopPropagation(); openProjMenu(kebab.dataset.kebab, kebab); return; }
     const card = e.target.closest('[data-open]');
     if (card) { openProject(card.dataset.open); return; }
-    if (e.target.closest('#ws-seed')) createSeeded();
+    const seed = e.target.closest('[data-seed-app]');
+    if (seed) {
+      const id = seed.dataset.seedApp;
+      const d = WORKSPACE_APPS[id];
+      if (d && d.seed === 'drawing') { seedPickApp = id; $seedFile.click(); } // drop-a-drawing: open the picker
+      else createSeeded(id); // takeoff import
+    }
   });
   $landing.addEventListener('keydown', (e) => {
     if (e.key !== 'Enter' && e.key !== ' ') return;
@@ -149,49 +272,156 @@
     if (card) { e.preventDefault(); openProject(card.dataset.open); }
   });
 
+  // Drop-a-drawing dropzone. A single hidden picker (outside $landing so an innerHTML re-render can't
+  // wipe it) backs the click-to-pick; dragover/drop are delegated on $landing so they survive the
+  // re-render too. The dashed card lights up (.drag-over) while a file hovers it.
+  let seedPickApp = null; // which app the pending pick/drop is for (set on click/drop)
+  const $seedFile = document.createElement('input');
+  $seedFile.type = 'file'; $seedFile.accept = '.pdf,image/*'; $seedFile.hidden = true;
+  document.body.appendChild($seedFile);
+  $seedFile.addEventListener('change', () => {
+    const file = ($seedFile.files || [])[0];
+    $seedFile.value = ''; // clear so re-picking the same file re-fires change
+    if (file && seedPickApp) createFromDrawing(seedPickApp, file);
+  });
+  $landing.addEventListener('dragover', (e) => {
+    const zone = e.target.closest('[data-seed-drop]');
+    if (!zone) return;
+    e.preventDefault();
+    zone.classList.add('drag-over');
+  });
+  $landing.addEventListener('dragleave', (e) => {
+    const zone = e.target.closest('[data-seed-drop]');
+    if (zone && !zone.contains(e.relatedTarget)) zone.classList.remove('drag-over');
+  });
+  $landing.addEventListener('drop', (e) => {
+    const zone = e.target.closest('[data-seed-drop]');
+    if (!zone) return;
+    e.preventDefault();
+    zone.classList.remove('drag-over');
+    const file = e.dataTransfer && e.dataTransfer.files && e.dataTransfer.files[0];
+    if (file) createFromDrawing(zone.dataset.seedDrop, file);
+  });
+
   async function promptName(title, label, value) {
     if (!bridge.formModal) return null;
     const res = await bridge.formModal({ title, fields: [{ name: 'name', label, value, placeholder: 'e.g. Westfield Retail — Ph2' }], okLabel: 'Save' });
     return res && typeof res.name === 'string' && res.name.trim() ? res.name.trim() : null;
   }
 
-  async function createSeeded() {
+  async function createSeeded(appId) {
     const name = await promptName('New project', 'Name this project', '');
     if (!name) return;
     try {
-      const { project, seeded } = await api('/api/projects', { method: 'POST', body: JSON.stringify({ name, app: WORKSPACE_APP, seedFromApp: true }) });
+      const { project, seeded } = await api('/api/projects', { method: 'POST', body: JSON.stringify({ name, app: appId, seedFromApp: true }) });
       // Tell the truth about the import: seeded=false means there was no current takeoff to copy
       // (or it was unreadable) — the project is EMPTY, don't imply the takeoff came across.
-      if (seeded) showToast(`Project "${project.name}" created from the current ${WORKSPACE_APP} takeoff`, 'ok');
-      else showToast(`Project "${project.name}" created — empty (no current ${WORKSPACE_APP} takeoff to import)`, 'warn');
+      if (seeded) showToast(`Project "${project.name}" created from the current ${appId} takeoff`, 'ok');
+      else showToast(`Project "${project.name}" created — empty (no current ${appId} takeoff to import)`, 'warn');
+      track('workspace_project_created', { app: appId }); // takeoff-import create path
       projects.unshift(project);
       openProject(project.id);
     } catch (err) { showToast('Couldn’t create the project: ' + (err && err.message || err), 'warn'); }
   }
 
+  // Drop-a-drawing create (vectorize). No new server verb: create an EMPTY project, then fire the
+  // existing revision pipeline (attachRevision) with the dropped file so the terminal AI reads it into
+  // v1. ROLLBACK on cancel/error — if the user cancels the name prompt, or the file can't be read,
+  // AFTER the row is created, archive the empty project so no dead, openable vectorize project is left
+  // behind (the row is created before the source exists — spec §4.1).
+  async function createFromDrawing(appId, file) {
+    // Ask for the name FIRST (before creating a row) so the common "cancel the prompt" path never
+    // creates anything to roll back.
+    const name = await promptName('New Vectorize project', 'Name this project', '');
+    if (!name) return;
+    let project;
+    try {
+      ({ project } = await api('/api/projects', { method: 'POST', body: JSON.stringify({ name, app: appId, seedFromApp: false }) }));
+    } catch (err) {
+      showToast('Couldn’t create the project: ' + (err && err.message || err), 'warn');
+      return;
+    }
+    // Validate the file is actually readable BEFORE queuing — a read failure here (after the row
+    // exists) must roll the empty project back rather than leave a dead one openable. attachRevision
+    // re-reads the file for the real pipeline; a tiny second read of the same file is harmless.
+    try { await readFileAsSnapshot(file); }
+    catch {
+      // Tailor the toast to what actually happened server-side: only claim the empty project was
+      // removed if the archive POST succeeded — otherwise it's still there and we must say so.
+      const removed = await archiveEmptyProject(project.id);
+      showToast(
+        removed
+          ? 'Couldn’t read the dropped drawing — the empty project was removed.'
+          : 'Couldn’t read the dropped drawing — an empty project was left behind; archive it from the ⋯ menu.',
+        'warn',
+      );
+      return;
+    }
+    track('workspace_project_created', { app: appId }); // drop-a-drawing create path (only once the row is kept, not rolled back)
+    projects.unshift(project);
+    openProject(project.id); // opens onto the project; the revision card reflects the queued read
+    attachRevision([file]); // reads the file → POSTs the revision-read Request for THIS project (self-toasting)
+  }
+
+  // Best-effort rollback of a just-created empty project (the existing archive path — recoverable).
+  // Returns true if the archive POST succeeded (removed server-side), false if it failed (a dead
+  // empty project was left behind) so the caller can tell the truth in its toast. Either way the
+  // local row is dropped so the landing doesn't keep showing it.
+  async function archiveEmptyProject(id) {
+    let removed = true;
+    try { await api(`/api/projects/${encodeURIComponent(id)}/archive`, { method: 'POST', body: '{}' }); }
+    catch { removed = false; /* leave it — the landing simply shows an empty project the user can archive manually */ }
+    projects = projects.filter((p) => p.id !== id);
+    return removed;
+  }
+
   // ── open project ────────────────────────────────────────────────────────────
   async function openProject(id) {
     let p = projects.find((x) => x.id === id);
     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(); }
+    // Never a broken open (spec §3.2): a project whose app has no client descriptor (uninstalled or
+    // renamed workspace app) can't be rendered — toast and bail BEFORE mutating any view state,
+    // matching the create-card skip. wsApp() would return null for it and the frame wiring would fail.
+    if (!WORKSPACE_APPS[p.app]) { showToast('This project’s app isn’t available as a workspace.', 'warn'); return; }
     current = p;
+    track('workspace_project_opened', { app: p.app }); // a real open (card click or post-create landing)
     lastRevState = 'none'; stopRevisionPoll(); // fresh project — drop any prior revision-poll state
     $projName.textContent = p.name;
     $crumbName.textContent = p.name;
     $status.textContent = p.app;
     // Lazily src the frames once per project; switching steps only toggles hidden so the
-    // editor's 3D state survives a Drawings⇄Model round-trip.
+    // editor's state survives a Source⇄Vectors round-trip. Frame URLs come from the app descriptor:
+    // the 'model' frame loads the app's editor; the 'drawings' frame loads its filter (steel) OR is
+    // left empty when the app has no filter step (vectorize — its Source step shows a placeholder).
+    const d = WORKSPACE_APPS[p.app]; // guaranteed present — the guard above bailed on an unknown app
     const qs = `?app=${encodeURIComponent(p.app)}&project=${encodeURIComponent(p.id)}`;
-    frames.model.dataset.want = `/steel-editor.html${qs}`;
-    frames.drawings.dataset.want = `/steel-filter.html${qs}`;
+    frames.model.dataset.want = `${d.editor}${qs}`;
+    frames.drawings.dataset.want = d.filter ? `${d.filter}${qs}` : '';
+    renderStepTabs(); // paint the tab labels for THIS app before the first step shows
     frames.model.src = 'about:blank'; frames.drawings.src = 'about:blank'; // reset any previous project
     frames.model.dataset.loaded = ''; frames.drawings.dataset.loaded = '';
     setStep('model');
     applyMode();
+    syncWorkspaceGuide(); // point the shared beacon at THIS project's document lifecycle
   }
-  function closeProject() { current = null; stopRevisionPoll(); lastRevState = 'none'; $revisionCard.hidden = true; closeProjMenu(); applyMode(); }
+  function closeProject() { current = null; stopRevisionPoll(); lastRevState = 'none'; $revisionCard.hidden = true; closeProjMenu(); applyMode(); syncWorkspaceGuide(); }
   document.getElementById('ws-back').addEventListener('click', closeProject);
 
+  // Paint the step-tab LABELS from the current app's descriptor (Source/Vectors for vectorize,
+  // Drawings/Model for steel). The data-step KEYS stay stable (drawings/model/exports/history) so
+  // setStep() and the frame slots are untouched — only the visible text differs. Label is set via
+  // textContent (never innerHTML) — it's a descriptor string, but textContent is the safe default.
+  function renderStepTabs() {
+    const d = wsApp();
+    if (!d) return;
+    const byKey = new Map(d.steps.map((st) => [st.key, st.label]));
+    $stepTabs.querySelectorAll('button[data-step]').forEach((b) => {
+      const label = byKey.get(b.dataset.step);
+      if (label) b.textContent = label;
+    });
+  }
+
   function setStep(s) {
     currentStep = s;
     $stepTabs.querySelectorAll('button').forEach((b) => {
@@ -199,11 +429,16 @@
       b.classList.toggle('active', on);
       b.setAttribute('aria-selected', String(on));
     });
+    // An app with no filter (vectorize) has an empty `drawings` frame URL — never src it; its Source
+    // step shows a lightweight placeholder pane instead of an about:blank iframe.
+    const d = wsApp();
+    const drawingsHasFrame = !!(d && d.filter);
     for (const [k, f] of Object.entries(frames)) {
-      const show = k === s;
+      const show = k === s && (k !== 'drawings' || drawingsHasFrame);
       f.hidden = !show;
-      if (show && !f.dataset.loaded) { f.src = f.dataset.want; f.dataset.loaded = '1'; }
+      if (show && !f.dataset.loaded && f.dataset.want) { f.src = f.dataset.want; f.dataset.loaded = '1'; }
     }
+    if ($sourcePlaceholder) $sourcePlaceholder.hidden = !(s === 'drawings' && !drawingsHasFrame);
     $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.
@@ -222,7 +457,7 @@
   });
 
   // ── Approve (per-project) ───────────────────────────────────────────────────
-  // Shared by the header ✓ Approve and the Exports-tab gate link ("Approve the model"), so the
+  // Shared by the header ✓ Approve and the Exports-tab gate link ("Approve this version"), so the
   // sign-off is one flow. On success it stamps current.approvedAt (server returns it) so the
   // Exports gate unlocks without a reload.
   async function approveProject() {
@@ -240,6 +475,11 @@
       const res = await api(`/api/contract/${encodeURIComponent(current.app)}/approve?project=${encodeURIComponent(current.id)}`, { method: 'POST' });
       if (res && res.approvedAt) current.approvedAt = res.approvedAt; // unlock exports
       showToast(`Approved — "${current.name}" is baked into ${current.app}`, 'ok');
+      track('workspace_project_approved', { app: current.app }); // a successful sign-off
+      // First Approve for this app calms the "✦ Start here" beacon (the document-archetype
+      // analog of a workflow's first Run); ticks the Review + Approve guide rows.
+      if (bridge.markWorkspaceApproved && wsHasDocGuide()) bridge.markWorkspaceApproved(current.app);
+      syncWorkspaceGuide();
       if (!$wsExports.hidden) renderExports(); // reflect the unlocked gate immediately if it's open
       if (!$wsHistory.hidden) renderHistory(); // a new version was recorded — reflect it + clear the banner
     } catch (err) {
@@ -300,6 +540,7 @@
     if (kind === 'bom-csv') return `${base}/export-bom/csv${qs}`;
     if (kind === 'bom-xlsx') return `${base}/export-bom/xlsx${qs}`;
     if (kind === 'ifc') return `${base}/export-ifc${qs}`;
+    if (kind === 'svg') return `${base}/export-svg${qs}`;
     return `${base}/export-tekla${qs}`; // tekla
   }
 
@@ -326,7 +567,7 @@
     }
     const exported = approved && c.file && exportState && exportState[c.kind] && exportState[c.kind].exportedAt;
     const label = exported ? 'Re-export' : c.verb;
-    const dis = approved ? '' : ' disabled data-tip="Approve the model first"';
+    const dis = approved ? '' : ' disabled data-tip="Approve this version first"';
     return `<div class="ecard">` +
       `<div class="e-top"><div class="e-ico">${escapeHtml(c.ico)}</div>` +
       `<div><div class="e-name">${escapeHtml(c.name)}</div><div class="e-fmt">${escapeHtml(c.fmt)}</div></div></div>` +
@@ -357,25 +598,29 @@
     // The user may have switched project/step during the await — don't paint stale.
     if (!current || current.id !== id || $wsExports.hidden) return;
     exportState = state;
+    syncWorkspaceGuide(); // fresh approve/export state → tick the Export (and re-sync Approve) guide rows
     const approved = !!approvedAt;
     let html = '';
     if (!approved) {
       html += `<div class="ws-exports-gate">Exports go out after sign-off — ` +
-        `<button type="button" id="ws-exports-approve">Approve the model</button> to enable them.</div>`;
+        `<button type="button" id="ws-exports-approve">Approve this version</button> to enable them.</div>`;
     }
     html += `<div class="exports-note"><b>Export at any stage</b> — polishing is optional. ` +
       `Each writes to this project’s <code>exports</code> folder.</div>`;
-    html += '<div class="export-grid">' + EXPORT_CARDS.map((c) => cardHtml(c, approved)).join('') + '</div>';
+    const cards = (wsApp() && wsApp().exports) || [];
+    html += '<div class="export-grid">' + cards.map((c) => cardHtml(c, approved)).join('') + '</div>';
     $wsExports.innerHTML = html;
   }
 
   async function doExport(kind) {
     if (!current) return;
+    const app = current.app; // capture — the user may switch projects during the await
     const btn = $wsExports.querySelector(`[data-export="${kind}"]`);
     const prev = btn ? btn.textContent : '';
     if (btn) { btn.disabled = true; btn.textContent = kind === 'tekla' ? 'Baking…' : 'Exporting…'; }
     try {
       const res = await api(exportUrl(kind), { method: 'POST' });
+      track('workspace_export', { app, kind }); // a successful export/bake (e.g. { app:'vectorize', kind:'svg' })
       if (kind === 'tekla') {
         const dropped = Array.isArray(res.skipped) ? res.skipped.length : 0;
         showToast((res.message || 'Baked into the Tekla model.') + (dropped ? ` · ${dropped} RFI member(s) skipped` : ''), 'ok');
@@ -562,7 +807,7 @@
       : `<span class="avatar ai">${escapeHtml((author || '?').replace(/[^A-Za-z0-9]/g, '').slice(0, 2).toUpperCase() || 'AI')}</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>';
+      return '<span class="gate-badge model" data-tip="Sign-off gate — this version was approved">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>';
@@ -575,9 +820,10 @@
     const action = v.current
       ? ''
       : `<button type="button" class="btn-mini" data-rollback="${escapeAttr(String(v.n))}" data-tip="Restore this version as a new version">↺ Rollback</button>`;
-    // "What changed" disclosure — only for a version that HAS a predecessor (n>1). v1 is the baseline,
-    // so it gets NO toggle at all (an ABSENT control, never a disabled one).
-    const canDiff = Number(v.n) > 1;
+    // "What changed" disclosure — only when the app HAS a semantic diff (steel; wsApp().diff) AND the
+    // version has a predecessor (n>1). v1 is the baseline, and a no-diff app (vectorize) gets NO toggle
+    // on ANY row — an ABSENT control, never a disabled one (spec §4.4, mirroring the v1-baseline branch).
+    const canDiff = !!(wsApp() && wsApp().diff) && Number(v.n) > 1;
     const toggle = canDiff
       ? `<button type="button" class="hd-toggle" data-diff="${escapeAttr(String(v.n))}" aria-expanded="false" data-tip="What changed vs the previous version"><span class="hd-caret">▸</span></button>`
       : '';
@@ -620,7 +866,7 @@
     if (!rows.length) {
       // Empty = an inline-action banner (never a bare header row that reads as broken/loading).
       $wsHistory.innerHTML =
-        '<div class="hist-empty">No versions yet — <button type="button" id="hist-approve">Approve the model</button> ' +
+        '<div class="hist-empty">No versions yet — <button type="button" id="hist-approve">Approve this version</button> ' +
         'to create <b>v1</b> and start the ledger.</div>';
       return;
     }
@@ -630,7 +876,7 @@
     const working = !approvedAt
       ? (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>'
+            `Open <b>${escapeHtml(stepLabel('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>')
       : '';

package/package.json

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