@1agh/maude 1.0.9 → 1.2.0

package/apps/studio/client/app.jsx

@@ -1218,6 +1218,37 @@ const PDF_DPI_OPTIONS = [
 ];
 const PDF_DPI_DEFAULT = 'auto';
 
+// issue #116 — how the export treats text. Mirrors export-dialog.tsx's
+// PDF_TEXT_OPTIONS (same mirror obligation as PDF_DPI_OPTIONS above).
+//
+// The list is FIXED regardless of whether Ghostscript is present on this
+// machine. Hiding "Convert to outlines" when gs is missing would need a new
+// capability route, and would answer the user's question ("can I send this to
+// a printer?") by making the answer invisible; a refusal that names the
+// one-line install is more honest and reaches them at the moment they care.
+const PDF_TEXT_OPTIONS = [
+  {
+    id: 'keep',
+    label: 'Keep selectable (default)',
+    description:
+      'Text stays selectable and searchable. You are warned if a font came out unprintable.',
+  },
+  {
+    id: 'embed',
+    label: 'Verify fonts embedded',
+    description:
+      'Same file, but the export fails instead of shipping a font a print shop would reject.',
+  },
+  {
+    id: 'outline',
+    label: 'Convert to outlines (print-safe)',
+    description:
+      'Every glyph becomes a vector path — no fonts left to break. Text is no longer selectable ' +
+      'and the file can grow a lot. Needs Ghostscript installed locally; cloud workspaces have it.',
+  },
+];
+const PDF_TEXT_DEFAULT = 'keep';
+
 // feature-bulk-media-insert — best-effort MIME guess from a filename extension.
 // Only used to classify a natively-picked file (Rust returns `{name, bytes}`,
 // no type) for the destination-toggle's image/video/audio split; the actual
@@ -1602,6 +1633,7 @@ function ExportDialog({
   const [pdfMarksCrop, setPdfMarksCrop] = useState(false);
   const [pdfMarksRegistration, setPdfMarksRegistration] = useState(false);
   const [pdfDpiId, setPdfDpiId] = useState(PDF_DPI_DEFAULT);
+  const [pdfTextId, setPdfTextId] = useState(PDF_TEXT_DEFAULT);
   // DDR-148 addendum — mp4/webm of a registered video-comp render through
   // renderMediaOnWeb, which produces real audio (Remotion owns the
   // TransitionSeries/volume-closure timeline). gif has no audio track at all
@@ -1714,6 +1746,10 @@ function ExportDialog({
       // itself stays vector regardless of this.
       const pdfDpi = PDF_DPI_OPTIONS.find((d) => d.id === pdfDpiId)?.value;
       if (pdfDpi !== undefined) options.dpi = pdfDpi;
+      // issue #116 — omitted for `keep` rather than sent explicitly: the
+      // adapter's default IS keep, so an untouched dialog produces the exact
+      // request body it did before this feature existed.
+      if (pdfTextId !== 'keep') options.text = pdfTextId;
     }
     // Scope targeting hints (resolveScope reads these): `artboardId` makes
     // "Active artboard" export the right screen instead of `:first-of-type`;
@@ -2022,6 +2058,27 @@ function ExportDialog({
                 The page stays vector; this only sets the capture density for raster content on it
                 (dropped photos, large-format art).
               </div>
+              <div className="st-dialog-row">
+                <label className="st-dialog-lbl" htmlFor="st-export-pdf-text">
+                  Text
+                </label>
+                <select
+                  id="st-export-pdf-text"
+                  className="st-select"
+                  data-testid="export-pdf-text"
+                  value={pdfTextId}
+                  onChange={(e) => setPdfTextId(e.target.value)}
+                >
+                  {PDF_TEXT_OPTIONS.map((t) => (
+                    <option key={t.id} value={t.id}>
+                      {t.label}
+                    </option>
+                  ))}
+                </select>
+              </div>
+              <div className="st-mono" style={{ fontSize: 11, color: 'var(--fg-3)' }}>
+                {PDF_TEXT_OPTIONS.find((t) => t.id === pdfTextId)?.description}
+              </div>
               <div className="st-dialog-row">
                 <label
                   className="st-dialog-lbl"
@@ -4548,6 +4605,10 @@ function Viewport({
   cfg,
   loadingPath,
   onIframeLoad,
+  canvasError,
+  canvasReloadNonce,
+  onRetryCanvasLoad,
+  loadedPath,
   showQuickSetup,
   onStartQuickSetup,
   previewPath,
@@ -4564,8 +4625,21 @@ function Viewport({
   useEffect(() => {
     if (previewPath) previewRef.current?.focus();
   }, [previewPath]);
+  // One observable word for "what is the canvas pane actually doing" — the
+  // top-frame signal the #115 E2E scenario waits on, and the only place these
+  // three states are named together. `ready` is `dgn:'loaded'`-backed, so it
+  // cannot be faked by a timer expiring (which is exactly how the bug used to
+  // look successful: skeleton gone, pane white).
+  const canvasState =
+    canvasError && canvasError.path === activePath
+      ? 'error'
+      : activePath && activePath !== SYSTEM_TAB && loadedPath === activePath
+        ? 'ready'
+        : loadingPath && loadingPath === activePath
+          ? 'loading'
+          : 'idle';
   return (
-    <div className="viewport st-stage" data-tour="viewport">
+    <div className="viewport st-stage" data-tour="viewport" data-canvas-state={canvasState}>
       {previewPath && (
         // feature-studio-file-preview — an overlay, not a tab: the canvas
         // iframe (if any) stays mounted underneath so switching back to it
@@ -4638,7 +4712,10 @@ function Viewport({
         }
         return (
           <iframe
-            key={t.path}
+            // The nonce is part of the key ONLY so the #115 Retry can force a
+            // remount; it is otherwise constant, so normal switching keys on the
+            // path exactly as before.
+            key={`${t.path}#${canvasReloadNonce}`}
             ref={(el) => registerIframe(t.path, el)}
             src={canvasUrl(t.path, cfg)}
             className={t.path === activePath ? 'active' : ''}
@@ -4669,6 +4746,45 @@ function Viewport({
           </div>
         </div>
       )}
+      {canvasError && canvasError.path === activePath && (
+        // issue #115 — what the blank pane used to be. Names which of the two
+        // failures happened and offers the recovery that used to require
+        // quitting the app (or knowing that switching projects and back
+        // re-reads /_config).
+        <div className="st-canvas-error" role="alert" data-testid="canvas-load-error">
+          <div className="st-canvas-error-card">
+            <div className="st-canvas-error-title">
+              {canvasError.kind === 'server'
+                ? "Maude's server isn't responding"
+                : "This canvas didn't finish loading"}
+            </div>
+            <div className="st-canvas-error-body">
+              {canvasError.kind === 'server' ? (
+                <>
+                  The canvas couldn't be reached. This usually means Maude's
+                  server restarted underneath this window — your files on disk
+                  are untouched.
+                </>
+              ) : (
+                <>
+                  The server is up, but{' '}
+                  <code>{sanitizeDisplayText(basename(canvasError.path))}</code>{' '}
+                  never finished compiling. Its own error, if it has one, is in
+                  the canvas frame.
+                </>
+              )}
+            </div>
+            <button
+              type="button"
+              className="btn btn--primary"
+              data-testid="canvas-load-retry"
+              onClick={() => onRetryCanvasLoad?.(canvasError.path)}
+            >
+              Reload canvas
+            </button>
+          </div>
+        </div>
+      )}
     </div>
   );
 }
@@ -9763,6 +9879,47 @@ function App() {
   // Phase 9 Task 8 — hub-down offline mode banner. Driven by the 'sync:status'
   // WS message the linked-mode sync runtime emits. null in solo mode.
   const [syncStatus, setSyncStatus] = useState(null);
+  // feature-large-project-seed — the NATIVE half of seed progress.
+  //
+  // A seed against a large project is minutes to hours of work, and the target
+  // user (DDR-177) never opens a terminal. The Sync panel is the detail view;
+  // this is what reaches them when the panel is not on screen: the window
+  // title while it runs, and ONE notification per phase transition.
+  //
+  // Per TRANSITION, never per file. A 2 961-file seed must produce two
+  // notifications, not 2 961 — `send_notification` throttles on the Rust side
+  // too, but a client that leans on that is a client that would spam a plain
+  // browser tab through the Web fallback.
+  const seedPhaseRef = useRef(null);
+  useEffect(() => {
+    const p = syncStatus?.files?.progress;
+    if (!p) return;
+    const prev = seedPhaseRef.current;
+    seedPhaseRef.current = p.phase;
+    if (prev === null || prev === p.phase) return;
+    if (p.phase === 'converged' && (prev === 'seeding' || prev === 'paused')) {
+      notifyDesktop('Project synced', `${p.delivered} files are up to date.`);
+    } else if (p.phase === 'blocked') {
+      const total = (p.blocked ?? []).reduce((n, b) => n + b.count, 0);
+      notifyDesktop(
+        'Sync needs a decision',
+        `${total} file${total === 1 ? '' : 's'} could not be sent. Open the Sync panel for the reason.`
+      );
+    }
+  }, [syncStatus?.files?.progress]);
+  // The title carries the count while a seed runs, and is restored afterwards —
+  // it is the one surface visible without opening anything.
+  useEffect(() => {
+    if (typeof document === 'undefined') return undefined;
+    const p = syncStatus?.files?.progress;
+    const base = document.title.replace(/\s+—\s+syncing\s+\d+\/\d+$/, '');
+    if (p && (p.phase === 'seeding' || p.phase === 'paused') && p.tracked > 0) {
+      document.title = `${base} — syncing ${p.delivered}/${p.tracked}`;
+    } else {
+      document.title = base;
+    }
+    return undefined;
+  }, [syncStatus?.files?.progress]);
   // DDR-218 — the folder's cloud link ({url, credentialed} | null), lifted from
   // CloudBar (status resolve / attach / detach). Gates the GitPanel's
   // cloud-managed posture; linked-but-uncredentialed keeps the full panel.
@@ -9790,6 +9947,24 @@ function App() {
   // Canvas-compile skeleton (single-canvas model → one path at a time).
   const [loadingPath, setLoadingPath] = useState(null);
   const loadFallbackTimer = useRef(null);
+  // issue #115 — a canvas that never reported `loaded`. `{ path, kind }`, where
+  // kind is 'server' (the canvas origin did not answer /_health — a dead or
+  // respawned sidecar) or 'compile' (the origin is up, the canvas itself never
+  // mounted). Rendered instead of the blank pane the cap used to leave behind.
+  const [canvasError, setCanvasError] = useState(null);
+  // Bumped by the error panel's Retry. Folded into the iframe `key` so a retry
+  // REMOUNTS the frame — re-setting `src` to the identical URL would not
+  // re-navigate, and after a respawn the URL is identical in every case except
+  // the port that `loadServerConfig()` is about to correct.
+  const [canvasReloadNonce, setCanvasReloadNonce] = useState(0);
+  // The canvas whose SHELL DOCUMENT has actually loaded, per its `dgn:'loaded'`
+  // post. Distinct from `!loadingPath`, which the 2.5 s onLoad fallback and the
+  // 15 s cap also clear — this one only ever means "the shell ran". That makes
+  // it the honest signal for `data-canvas-state` below, and the one the #115 E2E
+  // scenario asserts: the shell's inline script posts it whether or not the
+  // canvas TSX went on to build, so it isolates "the origin was reachable" from
+  // "the canvas compiled" — exactly the axis #115 is about.
+  const [loadedPath, setLoadedPath] = useState(null);
   // Resizable side panels (DS components-resize-panels) + the active drag side.
   const sbSize = usePanelSize('maude-sb-w', { min: 200, max: 420, def: 252 });
   const rpSize = usePanelSize('maude-rp-w', { min: 260, max: 480, def: 304 });
@@ -9825,11 +10000,6 @@ function App() {
       setLoadingPath((p) => (p === path ? null : p));
     }, 2500);
   }, []);
-  useEffect(() => {
-    if (!loadingPath) return;
-    const cap = setTimeout(() => setLoadingPath(null), 15000);
-    return () => clearTimeout(cap);
-  }, [loadingPath]);
   // Loaded at boot from /_config and re-fetched on the server's
   // `config-updated` push (config.json hot-reload — /design:setup-ds rewrites
   // it mid-session) — informs canvasUrl() so TSX iframes can pass the right
@@ -9846,6 +10016,44 @@ function App() {
   // for one frame, each fired the request its shell exists to refuse, and then
   // unmounted. Nothing was broken and everything looked broken.
   const [cfg, setCfg] = useState({ designRel: '.design', cloud: undefined });
+  // THE CAP MUST NOT CLEAR TO WHITE — issue #115. This used to be a bare
+  // `setLoadingPath(null)`, which is the most useless thing it could do: when
+  // the canvas origin is unreachable the shell HTML never loads, so the shell's
+  // own `#canvas-mount-error` surface (templates/_shell.html) does not exist to
+  // report anything, and dropping the skeleton left a blank pane with no error,
+  // no reason and no way back inside the app. Probe the canvas origin to tell
+  // the two failures apart — a dead server (the #115 stale-origin case, and any
+  // sidecar crash) versus a canvas that genuinely never finished compiling —
+  // and hand the user the recovery in both cases.
+  //
+  // DECLARED AFTER `cfg`, ON PURPOSE — the same rule the block below states for
+  // the git flags, and this effect is what taught us it is not decorative. Its
+  // dependency array reads `cfg?.canvasOrigin`, and A DEPENDENCY ARRAY IS
+  // EVALUATED DURING RENDER: sitting above the `useState` above, it hit `cfg` in
+  // its temporal dead zone, so `App` threw `Cannot access 'cfg' before
+  // initialization` on its very first render and the WHOLE STUDIO mounted
+  // nothing — a white page for every user, not only the desktop shell the fix
+  // was written for. It reached the branch because the PR carried a merge
+  // conflict, which stops GitHub from building a merge ref, which means the
+  // client-boot gate never ran on it (issue #112 close-out).
+  useEffect(() => {
+    if (!loadingPath) return;
+    const path = loadingPath;
+    const cap = setTimeout(async () => {
+      let kind = 'compile';
+      try {
+        const r = await fetch(`${cfg?.canvasOrigin || ''}/_health`, {
+          cache: 'no-store',
+        });
+        if (!r.ok) kind = 'server';
+      } catch {
+        kind = 'server';
+      }
+      setCanvasError({ path, kind });
+      setLoadingPath((p) => (p === path ? null : p));
+    }, 15000);
+    return () => clearTimeout(cap);
+  }, [loadingPath, cfg?.canvasOrigin]);
   // WHO IS SAVING THIS PROJECT — one expression, read by every surface that
   // would otherwise offer to save it, poll for it, or badge it (DDR-218, widened
   // by feature-cloud-managed-git-posture).
@@ -11471,12 +11679,30 @@ function App() {
     // 25 s keeps the socket active (Bun resets the idle timer on any frame,
     // inbound OR outbound); the server ignores an unknown message type.
     let pingTimer = null;
+    // A RECONNECT MEANS THE PEER MAY BE A DIFFERENT PROCESS — issue #115.
+    // The desktop supervisor respawns the sidecar when it dies (DDR-235's Bun
+    // fault is a recurring one), and everything this page cached from `/_config`
+    // was published by the process that just went away. `canvasOrigin` is the
+    // one that bites: it is an OS-assigned ephemeral port (server.ts's
+    // `startCanvasServer(0)`), so it is DIFFERENT in every process, while the
+    // main origin walks a deterministic ladder from 4399 and usually reclaims
+    // its old port. The result was a half-live page — socket back up, status bar
+    // `live`, tree and panels fine — whose every canvas iframe navigated to a
+    // dead port. Since a canvas switch mounts a FRESH iframe (single-canvas
+    // model, keyed by path), the already-open canvas kept rendering and only
+    // switching went white, silently and permanently.
+    //
+    // So: re-derive the config from whoever is answering now. Only on a
+    // RE-connect — the boot effect above already did the first fetch.
+    let everConnected = false;
     function connect() {
       const proto = location.protocol === 'https:' ? 'wss:' : 'ws:';
       const ws = new WebSocket(proto + '//' + location.host + '/_ws');
       wsRef.current = ws;
       ws.addEventListener('open', () => {
         setWsConnected(true);
+        if (everConnected) loadServerConfig();
+        everConnected = true;
         clearInterval(pingTimer);
         pingTimer = setInterval(() => {
           if (ws.readyState === WebSocket.OPEN) ws.send('{"type":"ping"}');
@@ -11826,11 +12052,27 @@ function App() {
     setActivePath(path);
     setFocusedCommentId(null);
     setPreviewPath(null);
+    setCanvasError(null);
+    setLoadedPath(null);
     // Canvas-compile skeleton — cleared by the iframe's dgn:'loaded' message,
     // the onLoad fallback timer (legacy .html), or a hard 15s cap.
     if (path !== SYSTEM_TAB) setLoadingPath(path);
   }, []);
 
+  // Retry from the #115 error panel: re-read /_config FIRST (the stale
+  // `canvasOrigin` is the likeliest reason we are here at all), then remount the
+  // iframe via the nonce so it navigates against the corrected origin.
+  const retryCanvasLoad = useCallback(
+    (path) => {
+      setCanvasError(null);
+      setLoadedPath(null);
+      loadServerConfig();
+      setCanvasReloadNonce((n) => n + 1);
+      if (path && path !== SYSTEM_TAB) setLoadingPath(path);
+    },
+    [loadServerConfig]
+  );
+
   /**
    * First open lands on a rendered canvas — Cloud Phase 27 C3.
    *
@@ -13132,6 +13374,10 @@ function App() {
         // iframe finished loading — drop the compile skeleton, push current
         // comments + carry over focused pin if any
         setLoadingPath((p) => (p === m.file ? null : p));
+        setLoadedPath(m.file);
+        // …and retire any #115 error panel for this canvas: it just proved it
+        // can load (a late load, or a successful Retry).
+        setCanvasError((e) => (e && e.path === m.file ? null : e));
         // Presentation Mode suppresses comment pins (same gate as the push
         // effect above), so a canvas opened while presenting starts pin-free.
         const list = presentMode ? [] : commentsByFile[m.file] || [];
@@ -15259,6 +15505,10 @@ function App() {
               cfg={cfg}
               loadingPath={loadingPath}
               onIframeLoad={onIframeLoad}
+              canvasError={canvasError}
+              canvasReloadNonce={canvasReloadNonce}
+              onRetryCanvasLoad={retryCanvasLoad}
+              loadedPath={loadedPath}
               showQuickSetup={
                 isNativeApp() && !viewerMode && !!setupReadiness && !setupReadiness.ready
               }

package/apps/studio/client/export-center.jsx

@@ -307,9 +307,11 @@ function StatusPill({ job }) {
         : job.status === 'done'
           ? degraded && job.degraded.audioDropped
             ? 'Ready · no audio'
-            : degraded
-              ? 'Ready · degraded'
-              : 'Ready'
+            : degraded && job.degraded.fontsNotEmbedded?.length
+              ? 'Ready · font warning'
+              : degraded
+                ? 'Ready · degraded'
+                : 'Ready'
           : 'Failed';
   const eta = job.status === 'running' ? etaLabel(job) : null;
   return (
@@ -331,12 +333,18 @@ function StatusPill({ job }) {
  */
 function DegradedNote({ degraded }) {
   if (!degraded) return null;
+  // The font case names the fonts, because "reduced fidelity" is useless to
+  // someone about to send this to a printer — what they need is which faces
+  // came out unprintable (issue #116).
+  const fonts = degraded.fontsNotEmbedded ?? [];
+  const headline = degraded.audioDropped
+    ? 'Exported without audio.'
+    : fonts.length
+      ? `Fonts a print shop will reject: ${fonts.join(', ')}.`
+      : 'Exported with reduced fidelity.';
   return (
     <div className="st-export-degraded" data-testid="export-degraded-note">
-      <span aria-hidden="true">⚠</span>{' '}
-      {degraded.audioDropped
-        ? 'Exported without audio.'
-        : 'Exported with reduced fidelity.'}
+      <span aria-hidden="true">⚠</span> {headline}
       {degraded.remedy ? <div className="st-export-degraded__fix">{degraded.remedy}</div> : null}
     </div>
   );

package/apps/studio/client/panels/ReadinessList.jsx

@@ -292,7 +292,13 @@ function Row({ item, refresh }) {
             ) : null}
           </span>
         ) : null}
-        {item.action === 'signin' && item.resolvedPath ? (
+        {/* Shown whenever a path resolved — NOT only in the signin state. DDR-166
+            Decision 3 calls this binding ("so a pre-existing PATH-hijacked `claude`
+            isn't invisible to the one human capable of noticing it's wrong"), and
+            gating it on `action === 'signin'` hid it in the one state whose most
+            likely cause IS something unexpected fronting the binary (issue #107,
+            attacker finding F4). */}
+        {item.resolvedPath ? (
           <span className="rdy-fix-tx rdy-resolved-path">
             {item.resolvedViaMaude ? 'Installed by Maude: ' : 'Found on your PATH: '}
             <code>{item.resolvedPath}</code>

package/apps/studio/client/panels/SyncPanel.jsx

@@ -98,6 +98,39 @@ function readFiles(raw) {
   return raw;
 }
 
+/**
+ * The seed progress model, or null when absent/untrustworthy.
+ *
+ * Absent is the norm on an older dev-server, and this panel must render
+ * exactly as it did before when it is — every field here is additive.
+ */
+function readProgress(raw) {
+  if (!raw || typeof raw !== 'object') return null;
+  if (![raw.tracked, raw.delivered, raw.remaining].every(isCount)) return null;
+  if (typeof raw.phase !== 'string') return null;
+  const blocked = Array.isArray(raw.blocked)
+    ? raw.blocked.filter((b) => b && typeof b.class === 'string' && isCount(b.count))
+    : [];
+  return { ...raw, blocked };
+}
+
+/** One sentence per phase, in the user's terms — never the machine's. */
+const PHASE_TEXT = {
+  scanning: 'Looking through the project…',
+  seeding: null, // the counts say it better than a sentence would
+  paused: 'Paused — nothing is lost; this resumes by itself.',
+  blocked: 'Nothing is moving on its own — the files below need a decision.',
+  converged: 'Everything is up to date.',
+};
+
+/** What each wall means, and what a person can do about it. */
+const BLOCKED_TEXT = {
+  'too-large': 'too big for this workspace',
+  quota: "this hour's upload allowance is used up",
+  unreachable: 'the workspace could not be reached',
+  refused: 'the workspace would not take them',
+};
+
 /** Consent-class notices (feature-before-first-external-users Task 1), or []
  *  when the shape can't be trusted. Absent is the norm — the payload carries
  *  `notices` only when a boot raised one (shared-doc ON, TSX bodies). */
@@ -279,6 +312,7 @@ export default function SyncPanel({
   const files = readFiles(status?.files);
 
   const delivery = useMemo(() => readDelivery(status?.files?.delivery), [status?.files?.delivery]);
+  const progress = useMemo(() => readProgress(status?.files?.progress), [status?.files?.progress]);
 
   // Sync settings (Task 2) — fetched once on mount; `settings` stays null when
   // no hub is linked, which is also the render gate for the whole section.
@@ -648,17 +682,98 @@ export default function SyncPanel({
         {files && (
           <section aria-label="Project files" data-testid="sync-files">
             <div className="gp-sect-label">
-              project files <span className="gp-group-count">{files.synced}</span>
-            </div>
-            <div className="sp-assets-line">
-              {`${files.synced} synced` + (files.pulled > 0 ? ` · ${files.pulled} pulled` : '')}
+              project files{' '}
+              <span className="gp-group-count">{progress ? progress.tracked : files.synced}</span>
             </div>
+            {progress ? (
+              <>
+                <div className="sp-progress-track" data-testid="sync-files-progress">
+                  <div
+                    className="sp-progress-fill"
+                    style={{
+                      width: `${
+                        progress.tracked > 0
+                          ? Math.min(100, Math.round((progress.delivered / progress.tracked) * 100))
+                          : 100
+                      }%`,
+                    }}
+                  />
+                </div>
+                <div className="sp-assets-line" data-testid="sync-files-remaining">
+                  {`${progress.delivered} of ${progress.tracked} delivered`}
+                  {progress.remaining > 0 ? ` · ${progress.remaining} waiting` : ''}
+                </div>
+                {PHASE_TEXT[progress.phase] && (
+                  <div className="sp-assets-line" data-testid="sync-files-phase">
+                    {PHASE_TEXT[progress.phase]}
+                  </div>
+                )}
+                {progress.passCapped && progress.remaining > 0 && (
+                  <div className="sp-assets-line">
+                    More is on the way — the last pass reached its limit and picks up where it
+                    left off.
+                  </div>
+                )}
+                {progress.blocked.map((b) => (
+                  <div
+                    key={b.class}
+                    className="sp-assets-retry"
+                    data-testid={`sync-blocked-${b.class}`}
+                  >
+                    {b.count} file{b.count === 1 ? '' : 's'} —{' '}
+                    {BLOCKED_TEXT[b.class] ?? 'the workspace would not take them'}.
+                  </div>
+                ))}
+                {/*
+                  THE RAW COUNTERS STAY. A panel derived from the same source it
+                  displays cannot be cross-checked, and DDR-214's whole lesson is
+                  that a status surface has to be falsifiable — so the numbers the
+                  passes actually reported remain here to disagree with.
+                */}
+                <div className="sp-assets-line sp-raw-counters">
+                  {`raw: ${files.synced} synced`}
+                  {files.pushed ? ` · ${files.pushed} pushed` : ''}
+                  {files.pulled > 0 ? ` · ${files.pulled} pulled` : ''}
+                </div>
+              </>
+            ) : (
+              <div className="sp-assets-line">
+                {`${files.synced} synced` + (files.pulled > 0 ? ` · ${files.pulled} pulled` : '')}
+              </div>
+            )}
             {files.conflicts > 0 && (
               <div className="sp-assets-retry" data-testid="sync-files-conflicts">
                 {files.conflicts} conflict{files.conflicts === 1 ? '' : 's'} — the older copies are
                 kept in Trash, below.
               </div>
             )}
+            {/*
+              A PAUSE IS NOT A FAILURE, and it gets its own words. The
+              workspace asked us to slow down; nothing is wrong, nothing is
+              lost, and the only correct action is to wait — which is exactly
+              what a person cannot infer from a count of failures (issue #109).
+              It comes FIRST because it explains the failure line below it.
+            */}
+            {files.rateLimited && (
+              <div className="sp-assets-retry" data-testid="sync-files-rate-limited">
+                <strong>syncing paused for a moment.</strong> The workspace asked this machine to
+                slow down.{' '}
+                {files.rateLimited.waiting > 0
+                  ? `${files.rateLimited.waiting} file${files.rateLimited.waiting === 1 ? '' : 's'} still on the way — nothing is lost, they arrive when the pause lifts.`
+                  : 'It resumes by itself.'}
+              </div>
+            )}
+            {/*
+              AND A FAILURE IS NOT A SYNC. This had no field at all, so a pass
+              that refused every file rendered as "N synced" and a person saw
+              broken images with the cause only in a terminal they never open.
+            */}
+            {files.failed > 0 && !files.rateLimited && (
+              <div className="sp-assets-retry" data-testid="sync-files-failed">
+                {files.failed} file{files.failed === 1 ? '' : 's'} did not come through on the last
+                check — sync retries them by itself. The list is below.
+              </div>
+            )}
             {/*
               A HELD BREAKER, said out loud. These used to exist only as a
               console.warn, which on a machine whose user never opens a
@@ -717,6 +832,12 @@ export default function SyncPanel({
                     </li>
                   ))}
                   {delivery.fine.length > 200 && <li>…and {delivery.fine.length - 200} more</li>}
+                  {files.deliveryTruncated > 0 && (
+                    <li className="sp-truncated">
+                      …and {files.deliveryTruncated} more not listed here — the list is capped so
+                      the files that need attention always fit.
+                    </li>
+                  )}
                 </ul>
               </details>
             )}

package/apps/studio/client/report-bug.jsx

@@ -321,6 +321,7 @@ export function ReportBugDialog({ open, onClose, activeCanvas = null }) {
       attachments: {
         screenshots: shots.length,
         serverLogTail: consent.logTail && !!bundle?.logs?.serverLogTail,
+        processStats: consent.logTail && !!bundle?.process,
         crashLogs: consent.crashLogs ? crashLogs.length : 0,
       },
       logs: {},
@@ -330,6 +331,19 @@ export function ReportBugDialog({ open, onClose, activeCanvas = null }) {
     if (consent.logTail && bundle?.logs?.serverLogTail) {
       report.logs.serverLogTail = bundle.logs.serverLogTail;
     }
+    // Server process memory — three integers, rides the SAME consent as the log
+    // tail because it is diagnostics of the same kind (and, like the tail, is
+    // only meaningful alongside it). Issue #119 arrived as a RAM figure the
+    // reporter read off Activity Monitor, with nothing in the report to confirm
+    // it; the memory watch that should have logged the problem was measuring a
+    // counter that does not move under Bun, so the log tail was silent too.
+    if (consent.logTail && bundle?.process) {
+      report.process = {
+        rssBytes: bundle.process.rssBytes,
+        heapUsedBytes: bundle.process.heapUsedBytes,
+        uptimeSeconds: bundle.process.uptimeSeconds,
+      };
+    }
     if (consent.crashLogs && crashLogs.length && isNativeApp()) {
       report.logs.crashLogs = [];
       for (const log of crashLogs) {
@@ -568,7 +582,11 @@ export function ReportBugDialog({ open, onClose, activeCanvas = null }) {
                     />
                     <span>
                       Recent server log ({bundle.logs.serverLogTail.split('\n').length} lines,
-                      paths &amp; secrets scrubbed) —{' '}
+                      paths &amp; secrets scrubbed)
+                      {bundle?.process
+                        ? ` + server memory (${Math.round(bundle.process.rssBytes / 1048576)} MB)`
+                        : ''}{' '}
+                      —{' '}
                       <details className="rb-details">
                         <summary>view</summary>
                         <pre className="rb-log">{bundle.logs.serverLogTail}</pre>