tmux-ide 2.9.0-beta.20 → 2.9.0-beta.21

package/packages/daemon/dist/tui/mirror/runtime/semantic-shell-viewport-resize.js

@@ -7,23 +7,113 @@ export function createSemanticShellViewportResizeOwner(getLayout = () => ({ curr
     let disposed = false;
     let applied = null;
     let pending = null;
+    let desired = null;
+    let scopedFlight = false;
+    let scopedEpoch = 0;
+    let authorityClient = null;
+    let stopAuthority = null;
+    let geometryOwner = null;
+    let authoritySuspended = false;
+    let retry = null;
+    const scopedApplied = new Map();
+    const targetKey = (target) => target.semanticWindowId ?? "";
+    const targetSize = (target) => `${target.cols}x${target.rows}`;
+    const drain = async () => {
+        if (scopedFlight || disposed || authoritySuspended)
+            return;
+        scopedFlight = true;
+        try {
+            while (desired && !disposed && !authoritySuspended) {
+                const owner = desired;
+                const epoch = scopedEpoch;
+                const target = owner.targets.find((entry) => scopedApplied.get(targetKey(entry)) !== targetSize(entry));
+                if (!target)
+                    break;
+                // A global fit clears this control client's window overrides. Forget
+                // them before dispatch, including a reversal while the receipt waits.
+                if (target.semanticWindowId === undefined)
+                    scopedApplied.clear();
+                else
+                    scopedApplied.delete(targetKey(target));
+                const outcome = await owner.identity.lane.lane
+                    .resize(target)
+                    .catch(() => ({ status: "failed" }));
+                if (disposed || !desired)
+                    break;
+                if (epoch !== scopedEpoch)
+                    continue;
+                const stillDesired = desired.targets.some((entry) => targetKey(entry) === targetKey(target) && targetSize(entry) === targetSize(target));
+                if (outcome.status !== "applied") {
+                    if (!stillDesired)
+                        continue;
+                    break;
+                }
+                // Preserve the actual accepted size even after a reversal so the next
+                // pass compares current truth with the latest complete desired set.
+                if (desired.targets.some((entry) => targetKey(entry) === targetKey(target)))
+                    scopedApplied.set(targetKey(target), targetSize(target));
+            }
+        }
+        finally {
+            scopedFlight = false;
+        }
+    };
+    const sameAuthority = (left, right) => left.lane === right.lane &&
+        left.daemonGeneration === right.daemonGeneration &&
+        left.rendererEpoch === right.rendererEpoch;
     const same = (left, right) => left?.lane === right.lane &&
         left.daemonGeneration === right.daemonGeneration &&
         left.rendererEpoch === right.rendererEpoch &&
         left.cols === right.cols &&
         left.rows === right.rows;
     return Object.freeze({
-        adopt(dimensions, semantic, generation, paneBorderStatus = getLayout().current?.paneBorderStatus ?? "off") {
+        adopt: function adopt(dimensions, semantic, generation, paneBorderStatus = getLayout().current?.paneBorderStatus ?? "off") {
             if (disposed)
                 return;
+            retry = () => adopt(dimensions, semantic, generation, paneBorderStatus);
             if (semantic === null ||
                 generation?.status !== "live" ||
                 generation.daemonGeneration === null ||
                 generation.fastLane === null) {
+                stopAuthority?.();
+                stopAuthority = null;
+                authorityClient = null;
+                authoritySuspended = false;
                 applied = null;
                 pending = null;
+                desired = null;
+                scopedEpoch += 1;
+                scopedApplied.clear();
                 return;
             }
+            if (authorityClient !== generation.authorityClient) {
+                stopAuthority?.();
+                authorityClient = generation.authorityClient;
+                const observed = authorityClient;
+                geometryOwner = observed?.getAuthoritySnapshot()?.owners.geometry ?? null;
+                authoritySuspended =
+                    geometryOwner !== null && geometryOwner !== observed?.authorityIdentity.clientId;
+                stopAuthority =
+                    observed?.onAuthority((snapshot) => {
+                        if (disposed ||
+                            authorityClient !== observed ||
+                            snapshot.generation !== generation.daemonGeneration)
+                            return;
+                        const next = snapshot.owners.geometry;
+                        if (next === geometryOwner)
+                            return;
+                        geometryOwner = next;
+                        authoritySuspended = next !== null && next !== observed.authorityIdentity.clientId;
+                        // The daemon clears scoped fits on handoff even when the host/runtime
+                        // identity survives. Reacquisition must rebuild them from current truth.
+                        applied = null;
+                        pending = null;
+                        scopedApplied.clear();
+                        scopedEpoch += 1;
+                        if (!authoritySuspended)
+                            retry?.();
+                    }) ?? null;
+            }
             const viewport = applicationShellViewport(dimensions, true);
             const lane = generation.fastLane;
             const target = Object.freeze({
@@ -33,8 +123,50 @@ export function createSemanticShellViewportResizeOwner(getLayout = () => ({ curr
                 cols: viewport.width,
                 rows: Math.max(2, viewport.height - (paneBorderStatus === "off" ? 1 : 0)),
             });
-            if (same(applied, target) || same(pending, target))
+            const windows = getLayout().windows;
+            if (windows &&
+                windows.every((window) => typeof window.semanticWindowId === "string" && window.semanticWindowId.length > 0)) {
+                applied = null;
+                pending = null;
+                if (!desired || !sameAuthority(desired.identity, target)) {
+                    scopedEpoch += 1;
+                    scopedApplied.clear();
+                }
+                const retainedWindows = new Set(["", ...windows.map((window) => window.semanticWindowId)]);
+                for (const key of scopedApplied.keys())
+                    if (!retainedWindows.has(key))
+                        scopedApplied.delete(key);
+                desired = {
+                    identity: target,
+                    targets: [
+                        // Unscoped/new windows inherit a stable size, independent of the
+                        // selected window's border policy. Known windows then fit their own
+                        // header reservation without resizing their neighbours on switch.
+                        { cols: viewport.width, rows: Math.max(2, viewport.height - 1) },
+                        ...windows.map((window) => ({
+                            semanticWindowId: window.semanticWindowId,
+                            cols: viewport.width,
+                            rows: Math.max(2, viewport.height - (window.paneBorderStatus === "off" ? 1 : 0)),
+                        })),
+                    ],
+                };
+                void drain();
                 return;
+            }
+            if (desired) {
+                desired = null;
+                scopedEpoch += 1;
+                scopedApplied.clear();
+                applied = null;
+                pending = null;
+            }
+            if (authoritySuspended || same(applied, target) || same(pending, target))
+                return;
+            // The accepted size stops being a dedupe target as soon as another
+            // resize can mutate tmux. Otherwise A -> B -> A drops the final A while
+            // B is still awaiting its receipt. The fast lane owns first/latest
+            // coalescing; it must see the reversal to retain the actual final size.
+            applied = null;
             pending = target;
             void lane.lane.resize({ cols: target.cols, rows: target.rows }).then((outcome) => {
                 if (disposed || pending !== target)
@@ -49,6 +181,12 @@ export function createSemanticShellViewportResizeOwner(getLayout = () => ({ curr
         },
         dispose() {
             disposed = true;
+            retry = null;
+            stopAuthority?.();
+            stopAuthority = null;
+            authorityClient = null;
+            desired = null;
+            scopedApplied.clear();
             applied = null;
             pending = null;
         },

package/packages/daemon/dist/tui/mirror/runtime/workspace-terminal-fast-lane.js

@@ -56,7 +56,9 @@ export function createOpenTuiWorkspaceTerminalFastLane(client, hostClientId, cau
                 if (client.getSnapshot().target?.daemon.instanceId !== address.generation) {
                     return Promise.resolve("authority-lost");
                 }
-                return client.fitViewport(viewport.cols, viewport.rows);
+                return viewport.semanticWindowId === undefined
+                    ? client.fitViewport(viewport.cols, viewport.rows)
+                    : client.fitViewport(viewport.cols, viewport.rows, viewport.semanticWindowId);
             },
         },
         ...(performanceSink?.terminalTraceStage

package/packages/daemon/dist/tui/mirror/semantic-pane-render-source.js

@@ -566,7 +566,8 @@ export function blitSemanticRow(row, buffers, y, width, defaultFg, defaultBg, gr
         let background = resolveColor(cell.background, false, palette);
         let attributes = cell.attributes;
         if ((attributes & 32) !== 0) {
-            [foreground, background] = [background, foreground];
+            // Resolve each side before reversing: a default retains its original role.
+            [foreground, background] = [background ?? defaultBg, foreground ?? defaultFg];
             attributes &= ~32;
         }
         // Native tmux clears a partial wide glyph, retaining its background.

package/packages/daemon/dist/tui/mirror/theme.js

@@ -12,6 +12,7 @@
 import { RGBA } from "@opentui/core";
 import { BUILTIN_VISUAL_THEMES, findVisualThemePreset, contrastRatio, deriveAttentionBlend, deriveFocusedHeader, mixSrgbColors, readableForeground, resolveVisualTheme, } from "@tmux-ide/contracts";
 import { LEGACY_THEME_OVERRIDE_PROVENANCE, } from "../../lib/legacy-theme-compat.js";
+import { parseTerminalHostColor, terminalHostMode } from "../../lib/terminal-host-color.js";
 import { XTERM_PALETTE } from "./ansi-palette.js";
 /** Stable categorical host accents; palette authority stays with the theme. */
 export const FLEET_HOST_ACCENT_COLORS = Object.freeze([
@@ -162,30 +163,6 @@ function rendererNeutral(red, green, blue) {
 function rendererNeutralFromPacked(color) {
     return rendererNeutral((color >> 16) & 0xff, (color >> 8) & 0xff, color & 0xff);
 }
-function perceivedLuminance(color) {
-    return 0.299 * color.red + 0.587 * color.green + 0.114 * color.blue;
-}
-function parseTerminalHostColor(value) {
-    if (!value)
-        return null;
-    const normalized = value.trim().toLowerCase();
-    const hex = /^#([\da-f]{3}|[\da-f]{6})$/u.exec(normalized)?.[1];
-    if (hex) {
-        const expanded = hex.length === 3 ? `${hex[0]}${hex[0]}${hex[1]}${hex[1]}${hex[2]}${hex[2]}` : hex;
-        return rendererNeutral(Number.parseInt(expanded.slice(0, 2), 16), Number.parseInt(expanded.slice(2, 4), 16), Number.parseInt(expanded.slice(4, 6), 16));
-    }
-    // OSC palette replies may use X11's rgb:RR/GG/BB form with one to four
-    // hexadecimal digits per channel. Scale each channel to a byte rather than
-    // truncating high-fidelity replies.
-    const x11 = /^rgb:([\da-f]{1,4})\/([\da-f]{1,4})\/([\da-f]{1,4})$/u.exec(normalized);
-    if (!x11)
-        return null;
-    const channel = (part) => {
-        const maximum = 16 ** part.length - 1;
-        return Math.round((Number.parseInt(part, 16) / maximum) * 255);
-    };
-    return rendererNeutral(channel(x11[1]), channel(x11[2]), channel(x11[3]));
-}
 function mostReadable(background, candidates, minimum = 4.5) {
     const unique = candidates.filter((candidate, index) => candidates.findIndex((other) => other.red === candidate.red &&
         other.green === candidate.green &&
@@ -214,19 +191,15 @@ function mutedHostText(panel, foreground) {
  */
 export function deriveSystemVisualHostDefaults(input) {
     const reportedPalette = Array.from({ length: 16 }, (_, index) => parseTerminalHostColor(input.palette[index]));
-    const measuredBackground = parseTerminalHostColor(input.defaultBackground) ?? reportedPalette[0] ?? null;
-    const measuredForeground = parseTerminalHostColor(input.defaultForeground) ?? reportedPalette[7] ?? null;
+    const measuredBackground = parseTerminalHostColor(input.defaultBackground);
+    const measuredForeground = parseTerminalHostColor(input.defaultForeground);
     if (!measuredBackground && !measuredForeground && reportedPalette.every((value) => !value))
         return null;
     const fallbackMode = input.detectedMode ?? "dark";
     const background = measuredBackground ?? BUILTIN_VISUAL_THEMES[fallbackMode].surfaces.canvas;
     const black = rendererNeutral(0, 0, 0);
     const white = rendererNeutral(255, 255, 255);
-    const appearance = measuredBackground === null
-        ? fallbackMode
-        : perceivedLuminance(background) > 127.5
-            ? "light"
-            : "dark";
+    const appearance = terminalHostMode(input.defaultBackground) ?? fallbackMode;
     const builtIn = BUILTIN_VISUAL_THEMES[appearance];
     const structuralTarget = appearance === "dark" ? white : black;
     const panel = mixSrgbColors(background, structuralTarget, appearance === "dark" ? 0.055 : 0.04);

package/packages/daemon/dist/tui/mirror/workspace/terminal-pane-header.jsx

@@ -1,7 +1,7 @@
 /* @jsxImportSource @opentui/solid */
 import { paneInteractionPresence } from "@tmux-ide/core";
 import { Badge } from "../ui/badge.jsx";
-import { createSignal, Show } from "solid-js";
+import { createMemo, createSignal, Show } from "solid-js";
 import { clipTerminal, terminalDisplayWidth } from "../terminal-text.js";
 import { AgentBadge, IconButton, componentPalette } from "../ui/index.js";
 function agentStatus(activity) {
@@ -49,13 +49,6 @@ export function PaneTitleBar(props) {
             return 0;
         return Math.min(available, terminalDisplayWidth(activityLabel()) + 2);
     };
-    // Capture one non-null presence for each badge lifetime. A retiring child's
-    // queued style effect must not dereference the parent's now-expired receipt.
-    const activityBadge = () => {
-        const current = presence();
-        const width = activityWidth();
-        return current && width > 0 ? { presence: current, width, label: activityLabel() } : null;
-    };
     // Keep the state glyph out of the first two inline cells. OpenTUI can repaint
     // those cells from the clipped parent during nested workspace composition.
     const markerGutterWidth = () => Math.min(2, safeWidth());
@@ -120,6 +113,20 @@ export function PaneTitleBar(props) {
         else
             props.onSelectIntent();
     };
+    // Capture one non-null presence for each badge lifetime. A retiring child's
+    // queued style effect must not dereference the parent's now-expired receipt.
+    const activityBadge = createMemo(() => {
+        const current = presence();
+        const width = activityWidth();
+        return current && width > 0 ? { presence: current, width, label: activityLabel() } : null;
+    }, undefined, {
+        equals: (previous, next) => previous === next ||
+            (previous !== null &&
+                next !== null &&
+                previous.width === next.width &&
+                previous.label === next.label &&
+                previous.presence.tone === next.presence.tone),
+    });
     return (<box id={`pane-title-bar:${props.paneId}`} position="absolute" left={0} top={0} width={safeWidth()} height={1} zIndex={2} flexDirection="row" overflow="hidden" backgroundColor={palette().background} onMouseOver={() => setPointerInside(true)} onMouseOut={() => setPointerInside(false)} onMouseDown={selectOrOpenMenu}>
       <text width={markerGutterWidth()} height={1} flexShrink={0} bg={palette().background} onMouseDown={selectOrOpenMenu}>
         {" ".repeat(markerGutterWidth())}

package/packages/daemon/src/command-center/diagnostics.ts

@@ -0,0 +1,75 @@
+import { performance } from "node:perf_hooks";
+import type { DaemonInstanceIdentity } from "@tmux-ide/contracts";
+import type { Hono } from "hono";
+import { requireOwnerAuthority } from "./owner-authority.ts";
+
+/** One synchronous, demand-only sample. No observers, discovery, or retained baseline. */
+export function sampleDaemonDiagnostics(daemon: DaemonInstanceIdentity) {
+  const sampledAtMs = Date.now();
+  const memory = process.memoryUsage();
+  const cpu = process.cpuUsage();
+  const eventLoop = performance.eventLoopUtilization();
+  // Fixed output cardinality. Unknown runtime resource labels are never echoed.
+  const activeResources = {
+    Timeout: 0,
+    Immediate: 0,
+    TCPServerWrap: 0,
+    TCPSocketWrap: 0,
+    PipeWrap: 0,
+    ProcessWrap: 0,
+    FSEventWrap: 0,
+    other: 0,
+  };
+  const resourceNames = process.getActiveResourcesInfo?.();
+  for (const resource of resourceNames ?? []) {
+    if (Object.hasOwn(activeResources, resource) && resource !== "other") {
+      activeResources[resource as keyof typeof activeResources]++;
+    } else {
+      activeResources.other++;
+    }
+  }
+  return {
+    daemon: {
+      protocolVersion: daemon.protocolVersion,
+      productVersion: daemon.productVersion,
+      instanceId: daemon.instanceId,
+      startedAt: daemon.startedAt,
+      ...(daemon.environmentId !== undefined ? { environmentId: daemon.environmentId } : {}),
+    },
+    pid: process.pid,
+    uptimeMs: process.uptime() * 1000,
+    sampledAtMs,
+    memory: {
+      rss: memory.rss,
+      heapTotal: memory.heapTotal,
+      heapUsed: memory.heapUsed,
+      external: memory.external,
+      arrayBuffers: memory.arrayBuffers,
+    },
+    cpu: { user: cpu.user, system: cpu.system },
+    eventLoop: {
+      idle: eventLoop.idle,
+      active: eventLoop.active,
+      utilization: eventLoop.utilization,
+    },
+    activeResources: resourceNames === undefined ? null : activeResources,
+  };
+}
+
+export function mountDiagnosticsRoute(
+  app: Hono,
+  options: { daemon: DaemonInstanceIdentity; ownerToken: string | null },
+) {
+  app.get(
+    "/api/diagnostics",
+    requireOwnerAuthority(options.ownerToken, {
+      whenOwnerless: "unavailable",
+      unavailableMessage: "Diagnostics unavailable",
+      mismatchMessage: "Diagnostics require owner authority",
+    }),
+    (c) => {
+      c.header("Cache-Control", "no-store");
+      return c.json(sampleDaemonDiagnostics(options.daemon));
+    },
+  );
+}

package/packages/daemon/src/command-center/log-stream.ts

@@ -19,6 +19,7 @@ export async function streamBoundedLogs(
     entries?: number;
     bytes?: number;
     writeTimeoutMs?: number;
+    heartbeatIntervalMs?: number;
   },
 ): Promise<void> {
   const maxEntries = options.entries ?? 256;
@@ -29,6 +30,7 @@ export async function streamBoundedLogs(
   let wake: (() => void) | null = null;
   let unsubscribe = () => {};
   let timer: ReturnType<typeof setTimeout> | null = null;
+  let heartbeatTimer: ReturnType<typeof setInterval> | null = null;
   let cancelWrite: (() => void) | null = null;
   const cleanup = () => {
     if (closed) return;
@@ -38,6 +40,8 @@ export async function streamBoundedLogs(
     bytes = 0;
     if (timer) clearTimeout(timer);
     timer = null;
+    if (heartbeatTimer) clearInterval(heartbeatTimer);
+    heartbeatTimer = null;
     wake?.();
     wake = null;
     cancelWrite?.();
@@ -67,6 +71,10 @@ export async function streamBoundedLogs(
     unsubscribe();
     return;
   }
+  heartbeatTimer = setInterval(() => {
+    if (!closed && queue.length === 0 && !push({ event: "heartbeat", data: "keep-alive" })) abort();
+  }, options.heartbeatIntervalMs ?? 15_000);
+  heartbeatTimer.unref?.();
   try {
     // Keep newest bounded history, reserving room for gap/bookmark metadata.
     const retained: Frame[] = [];

package/packages/daemon/src/command-center/server.ts

@@ -155,6 +155,7 @@ import { mountWorkspaceResourceRoutes } from "./resources/workspace-resource-rou
 import { mountFleetResourceRoute } from "./resources/fleet-resource-route.ts";
 import { mountWorkspaceMissionsRoute } from "./resources/workspace-missions-route.ts";
 import { ownerAuthorityGate, requireOwnerAuthority } from "./owner-authority.ts";
+import { mountDiagnosticsRoute } from "./diagnostics.ts";
 import {
   mountStartupReadinessRoute,
   type StartupReadinessAttachmentAuthority,
@@ -532,6 +533,13 @@ export function createApp(options: CreateAppOptions = {}): Hono {
   // Allow cross-origin (Next.js dashboard, Tailscale, etc.)
   app.use("/*", cors());
 
+  // Owner-only reads use the same early routing boundary as issuance below:
+  // remote/project credentials neither authorize nor block the owner bearer.
+  mountDiagnosticsRoute(app, {
+    daemon: daemonInstanceIdentity,
+    ownerToken: options.remoteAccess?.ownerToken ?? null,
+  });
+
   // This exact route carries its own owner-only bearer and correlation gate.
   // Mount it before remote and project auth so a valid host capability is
   // neither rejected nor confused with any remotely shared user credential.

package/packages/daemon/src/lib/app-config.ts

@@ -84,7 +84,9 @@ export interface AppThemeGlyphs {
  * reads as one system.
  */
 export interface AppTheme {
-  /** Explicit palette mode or terminal-following mode. Default keeps legacy dark visuals. */
+  /** Improve composed app text contrast. Default true. */
+  automaticContrast: boolean;
+  /** Explicit palette mode or terminal-following mode. Defaults to following the terminal. */
   mode: ThemeModeSetting;
   preset?: string;
   /** Primary/brand accent (default `colour75`). */
@@ -263,7 +265,8 @@ export const DEFAULT_APP_CONFIG: AppConfig = {
     panels: { explorer: "M-e", changes: "M-g", config: "M-," },
   },
   theme: {
-    mode: "dark",
+    automaticContrast: true,
+    mode: "system",
     accent: "colour75",
     muted: "colour240",
     fg: "colour250",
@@ -395,7 +398,12 @@ export function parseAppConfig(input: unknown): AppConfig {
       },
     },
     theme: {
-      mode: pickChoice(theme.mode, ["dark", "light", "system"], D.theme.mode),
+      automaticContrast: pickBool(theme.automaticContrast, D.theme.automaticContrast),
+      mode: pickChoice(
+        theme.mode,
+        ["dark", "light", "system"],
+        findVisualThemePreset(theme.preset)?.appearance ?? D.theme.mode,
+      ),
       ...(findVisualThemePreset(theme.preset) ? { preset: String(theme.preset) } : {}),
       accent: pickString(theme.accent, D.theme.accent),
       muted: pickString(theme.muted, D.theme.muted),

package/packages/daemon/src/lib/soak-diagnostics.ts

@@ -0,0 +1,183 @@
+/** Pure, allowlisted evidence projection. Never retain response bodies or errors. */
+export const DIAGNOSTICS_MAX_BYTES = 16_384;
+export const RESOURCE_KEYS = [
+  "Timeout",
+  "Immediate",
+  "TCPServerWrap",
+  "TCPSocketWrap",
+  "PipeWrap",
+  "ProcessWrap",
+  "FSEventWrap",
+  "other",
+] as const;
+export const MEMORY_KEYS = ["rss", "heapTotal", "heapUsed", "external", "arrayBuffers"] as const;
+export interface DiagnosticsIdentity {
+  protocolVersion: number;
+  productVersion: string;
+  instanceId: string;
+  startedAt: string;
+  environmentId?: string;
+}
+export interface DiagnosticsSample {
+  daemon: DiagnosticsIdentity;
+  pid: number;
+  uptimeMs: number;
+  sampledAtMs: number;
+  memory: Record<(typeof MEMORY_KEYS)[number], number>;
+  cpu: { user: number; system: number };
+  eventLoop: { idle: number; active: number; utilization: number };
+  activeResources: Record<(typeof RESOURCE_KEYS)[number], number> | null;
+}
+export type DiagnosticsResult =
+  | { status: "ok"; sample: DiagnosticsSample }
+  | {
+      status:
+        | "missing"
+        | "unsupported-endpoint"
+        | "http-error"
+        | "transport-error"
+        | "malformed"
+        | "identity-mismatch";
+      sample: null;
+    };
+const object = (v: unknown): v is Record<string, unknown> =>
+  !!v && typeof v === "object" && !Array.isArray(v);
+const number = (v: unknown): v is number => typeof v === "number" && Number.isFinite(v) && v >= 0;
+const text = (v: unknown): v is string => typeof v === "string" && v.length > 0 && v.length <= 256;
+function numeric<K extends string>(
+  v: unknown,
+  keys: readonly K[],
+  integer = false,
+): Record<K, number> | null {
+  if (!object(v) || !keys.every((k) => number(v[k]) && (!integer || Number.isSafeInteger(v[k]))))
+    return null;
+  return Object.fromEntries(keys.map((k) => [k, v[k]])) as Record<K, number>;
+}
+export function parseSoakDiagnostics(
+  body: string | null,
+  status: number,
+  expected: DiagnosticsIdentity & { pid: number },
+): DiagnosticsResult {
+  const fail = (status: Exclude<DiagnosticsResult["status"], "ok">): DiagnosticsResult => ({
+    status,
+    sample: null,
+  });
+  if (status === 404) return fail("unsupported-endpoint");
+  if (status !== 200) return fail("http-error");
+  if (body === null || body === "") return fail("missing");
+  if (new TextEncoder().encode(body).length > DIAGNOSTICS_MAX_BYTES) return fail("malformed");
+  let raw: unknown;
+  try {
+    raw = JSON.parse(body);
+  } catch {
+    return fail("malformed");
+  }
+  if (!object(raw) || !object(raw.daemon)) return fail("malformed");
+  const d = raw.daemon;
+  if (
+    !Number.isSafeInteger(d.protocolVersion) ||
+    !number(d.protocolVersion) ||
+    !text(d.productVersion) ||
+    !text(d.instanceId) ||
+    !text(d.startedAt) ||
+    !Number.isFinite(Date.parse(d.startedAt)) ||
+    (d.environmentId !== undefined && !text(d.environmentId)) ||
+    !Number.isSafeInteger(raw.pid) ||
+    !number(raw.pid) ||
+    raw.pid === 0
+  )
+    return fail("malformed");
+  if (
+    ["protocolVersion", "productVersion", "instanceId", "startedAt", "environmentId"].some(
+      (k) => d[k] !== expected[k as keyof DiagnosticsIdentity],
+    ) ||
+    raw.pid !== expected.pid
+  )
+    return fail("identity-mismatch");
+  const memory = numeric(raw.memory, MEMORY_KEYS, true);
+  const cpu = numeric(raw.cpu, ["user", "system"], true);
+  const eventLoop = numeric(raw.eventLoop, ["idle", "active", "utilization"]);
+  const activeResources =
+    raw.activeResources === null ? null : numeric(raw.activeResources, RESOURCE_KEYS, true);
+  if (
+    !memory ||
+    !cpu ||
+    !eventLoop ||
+    eventLoop.utilization > 1 ||
+    !number(raw.uptimeMs) ||
+    !number(raw.sampledAtMs) ||
+    (raw.activeResources !== null && !activeResources)
+  )
+    return fail("malformed");
+  return {
+    status: "ok",
+    sample: {
+      daemon: {
+        protocolVersion: d.protocolVersion,
+        productVersion: d.productVersion,
+        instanceId: d.instanceId,
+        startedAt: d.startedAt,
+        ...(d.environmentId !== undefined ? { environmentId: d.environmentId } : {}),
+      },
+      pid: raw.pid,
+      uptimeMs: raw.uptimeMs,
+      sampledAtMs: raw.sampledAtMs,
+      memory,
+      cpu,
+      eventLoop,
+      activeResources,
+    },
+  };
+}
+export type DiagnosticsDelta =
+  | {
+      status: "ok";
+      intervalMs: number;
+      cpuUserMicros: number;
+      cpuSystemMicros: number;
+      cpuPercent: number;
+      eventLoopIdleMs: number;
+      eventLoopActiveMs: number;
+      eventLoopUtilization: number | null;
+    }
+  | {
+      status: "missing-baseline" | "identity-mismatch" | "counter-regression" | "invalid-interval";
+    };
+/** Uptime is monotonic; wall-clock jumps do not change interval rates. */
+export function diagnosticsDelta(
+  previous: DiagnosticsSample | null,
+  current: DiagnosticsSample,
+): DiagnosticsDelta {
+  if (!previous) return { status: "missing-baseline" };
+  if (
+    previous.pid !== current.pid ||
+    ["protocolVersion", "productVersion", "instanceId", "startedAt", "environmentId"].some(
+      (key) =>
+        previous.daemon[key as keyof DiagnosticsIdentity] !==
+        current.daemon[key as keyof DiagnosticsIdentity],
+    )
+  )
+    return { status: "identity-mismatch" };
+  const intervalMs = current.uptimeMs - previous.uptimeMs;
+  if (!Number.isFinite(intervalMs) || intervalMs <= 0) return { status: "invalid-interval" };
+  const cpuUserMicros = current.cpu.user - previous.cpu.user;
+  const cpuSystemMicros = current.cpu.system - previous.cpu.system;
+  const eventLoopIdleMs = current.eventLoop.idle - previous.eventLoop.idle;
+  const eventLoopActiveMs = current.eventLoop.active - previous.eventLoop.active;
+  if (![cpuUserMicros, cpuSystemMicros, eventLoopIdleMs, eventLoopActiveMs].every(number))
+    return { status: "counter-regression" };
+  const cpuPercent = (cpuUserMicros + cpuSystemMicros) / (intervalMs * 10);
+  if (!Number.isFinite(cpuPercent)) return { status: "invalid-interval" };
+  const eventTotal = eventLoopIdleMs + eventLoopActiveMs;
+  if (!Number.isFinite(eventTotal)) return { status: "invalid-interval" };
+  return {
+    status: "ok",
+    intervalMs,
+    cpuUserMicros,
+    cpuSystemMicros,
+    cpuPercent,
+    eventLoopIdleMs,
+    eventLoopActiveMs,
+    eventLoopUtilization: eventTotal === 0 ? null : eventLoopActiveMs / eventTotal,
+  };
+}