fix(webapp): emit mollifier drainer LOG event as marker, not back-dated bar

engine.trigger rewrites the run's root span at materialisation (adopts
the synth root via traceId/spanId carryover but updates start_time to
"now"). A back-dated LOG event with startTime = bufferedAt landed
before that root start and got clipped from the trace tree —
persisted in ClickHouse but invisible to the admin viewing the page.

Emit it as a zero-duration marker AT materialisation time instead,
matching the [engine] QUEUED / PENDING_EXECUTING pattern. The
historical window is preserved in metadata so admins can still read
bufferedAt / dwellMs / attempts off the span detail pane.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: d-cs

apps/webapp/app/v3/mollifier/mollifierDrainerHandler.server.ts

@@ -217,23 +217,32 @@ export function createDrainerHandler(deps: {
         }
 
         // Admin-only audit trail emitted once engine.trigger has
-        // landed a PG row. `recordRunDebugLog` flips this to
-        // `TaskEventKind.LOG`, which the trace view + logs download
-        // already gate behind admin
+        // landed a PG row. `recordRunDebugLog` flips this to the
+        // admin-gated debug kind (TaskEventKind.LOG in the PG store /
+        // DEBUG_EVENT in the ClickHouse store) which the trace view +
+        // logs download already strip for non-admins
         // (`eventRepository.server.ts:108`,
-        // `resources.runs.$runParam.logs.download.ts:118`). Encoding
-        // the buffered window as `startTime` + `duration` makes the
-        // event render at the historical instant inside the run's
-        // existing trace — admins see "Mollifier buffered for Xms"
-        // sitting between trigger and dequeue. Best-effort: the
-        // helper has its own try/catch and returns a result, so it
-        // never throws into the materialisation path. Failures are
-        // logged but not surfaced because the customer-visible run
-        // has already landed.
+        // `resources.runs.$runParam.logs.download.ts:118`).
+        //
+        // Placement: emit as a zero-duration marker AT materialisation
+        // time, not as a back-dated bar spanning the buffered window.
+        // `engine.trigger` rewrites the run's root span at
+        // materialisation (it adopts the synth root via traceId/spanId
+        // carryover but updates start_time to "now"), so the trace
+        // renderer treats materialisation time as t=0. A back-dated
+        // event with startTime = bufferedAt would land before that t=0
+        // and get clipped from the tree. Same pattern as the
+        // `[engine] QUEUED` markers. The window itself is preserved
+        // in metadata so admins can read it off the span detail pane.
+        //
+        // Best-effort: `recordRunDebugLog` has its own try/catch and
+        // returns a result, so it never throws into the materialisation
+        // path. Failures are logged but not surfaced because the
+        // customer-visible run has already landed.
         if (triggerSucceeded) {
           const debugResult = await recordRunDebugLog(
             RunId.fromFriendlyId(input.runId),
-            `Mollifier buffered for ${dwellMs}ms before materialising`,
+            `Mollifier buffered ${dwellMs}ms before materialising`,
             {
               attributes: {
                 runId: input.runId,
@@ -244,8 +253,6 @@ export function createDrainerHandler(deps: {
                   "mollifier.attempts": input.attempts,
                 },
               },
-              startTime: input.createdAt,
-              duration: dwellMs * 1_000_000,
               parentId: snapshotSpanId,
             }
           );

apps/webapp/test/mollifierDrainerHandler.test.ts

@@ -497,14 +497,18 @@ describe("createDrainerHandler", () => {
     // Internal cuid derived from the friendlyId, mirroring what
     // `findRunForEventCreation` queries on.
     expect(callRunId).toBe("z");
-    expect(message).toMatch(/Mollifier buffered for \d+ms/);
-    // Encodes the historical buffered window so the trace view places
-    // the LOG event between trigger and dequeue (not at "now").
-    expect(options.startTime).toBe(bufferedAt);
-    expect(options.duration).toBeGreaterThan(0);
+    expect(message).toMatch(/Mollifier buffered \d+ms before materialising/);
+    // Emitted as a marker at materialisation time (no `startTime` /
+    // `duration` overrides) — engine.trigger has just rewritten the
+    // root span's start_time to "now", so back-dating the event would
+    // clip it off-screen in the trace renderer. The historical window
+    // is preserved in metadata so admins can still read it.
+    expect(options.startTime).toBeUndefined();
+    expect(options.duration).toBeUndefined();
     expect(options.parentId).toBe("snapspan");
     expect(options.attributes.metadata["mollifier.bufferedAt"]).toBe(bufferedAt.toISOString());
     expect(options.attributes.metadata["mollifier.attempts"]).toBe(2);
+    expect(options.attributes.metadata["mollifier.dwellMs"]).toBeGreaterThan(0);
   });
 
   it("does NOT emit the admin LOG event when engine.trigger fails non-retryably", async () => {