tmux-ide 2.9.0-beta.19 → 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/dist/tui/team/wait-receipts.js

@@ -2,12 +2,11 @@
  * Receipt-driven `wait agent-status` — the push twin of the polling loop in
  * `wait.ts`.
  *
- * When a canonical daemon is running, its agent-status watcher already
- * observes every `@agent_state` transition and emits a typed
- * `agent.turn-completed` receipt on the `/ws/events` bus. Waiting on that
- * receipt replaces the CLI's local poll (which re-scrapes the whole fleet
- * every 750 ms) with a single WebSocket that sits idle until the daemon
- * pushes the completion.
+ * Daemon completion receipts and session invalidations are wake-up hints, not
+ * proof that the whole session reached a status. Re-read the same aggregate
+ * session status as the polling path: another agent may still be working or
+ * blocked. Neither transport proves success of a submitted task. Bursts of
+ * hints share one read, with a persistent classification tracker.
  *
  * Honest degrade: this path only answers for the receipt-covered targets
  * (`done` / `idle` — the "turn finished" statuses). Every other case — no
@@ -16,7 +15,7 @@
  * existing polling implementation. A timeout is a real answer, not a fallback.
  *
  * Deps are injected (daemon record reader, liveness probe, socket factory,
- * one-shot status read, clock) so the waiting logic unit-tests without a
+ * aggregate status read, clock) so the waiting logic unit-tests without a
  * daemon; the exported defaults wire the real io.
  */
 import { WebSocket as WsWebSocket } from "ws";
@@ -26,7 +25,7 @@ import { createStatusTracker } from "../detect/classify.js";
 import { findSessionStatus } from "./report.js";
 import { listTeamSessions } from "./sessions.js";
 import { WAIT_DEFAULT_TIMEOUT_MS } from "./wait.js";
-/** How long to give the daemon socket to open before falling back to polling. */
+/** How long to allow socket open, hello and observer-install acknowledgement before falling back to polling. */
 export const RECEIPT_CONNECT_TIMEOUT_MS = 1_500;
 /** The statuses a turn-completed receipt can settle; all others need the poll. */
 export function isReceiptCoveredStatus(want) {
@@ -52,6 +51,17 @@ function messageText(data) {
 export async function waitForAgentStatusViaReceipts(session, want, opts = {}) {
     if (!isReceiptCoveredStatus(want))
         return null;
+    const timeoutMs = opts.timeoutMs ?? WAIT_DEFAULT_TIMEOUT_MS;
+    const now = opts.now ?? Date.now;
+    const started = now();
+    const timedOut = () => ({
+        ok: false,
+        session,
+        want,
+        status: null,
+        timedOutAfterMs: timeoutMs,
+    });
+    const remaining = () => Math.max(0, timeoutMs - (now() - started));
     const readInfo = opts.readDaemonInfo ?? readCanonicalDaemonInfo;
     let info;
     try {
@@ -63,9 +73,26 @@ export async function waitForAgentStatusViaReceipts(session, want, opts = {}) {
     if (!info)
         return null;
     const probeAlive = opts.probeAlive ?? isCanonicalDaemonAlive;
-    if (!(await probeAlive(info)))
+    let probeTimer;
+    try {
+        const alive = await Promise.race([
+            probeAlive(info),
+            new Promise((resolve) => {
+                probeTimer = setTimeout(() => resolve(null), remaining());
+                probeTimer.unref?.();
+            }),
+        ]);
+        if (alive === null || remaining() === 0)
+            return timedOut();
+        if (!alive)
+            return null;
+    }
+    catch {
         return null;
-    const timeoutMs = opts.timeoutMs ?? WAIT_DEFAULT_TIMEOUT_MS;
+    }
+    finally {
+        clearTimeout(probeTimer);
+    }
     const connectTimeoutMs = opts.connectTimeoutMs ?? RECEIPT_CONNECT_TIMEOUT_MS;
     // A loopback-bound daemon admits same-machine upgrades without a token; a
     // remote-bound daemon enforces its token even locally, so present the one
@@ -73,8 +100,8 @@ export async function waitForAgentStatusViaReceipts(session, want, opts = {}) {
     const authToken = info.authToken;
     const openSocket = opts.openSocket ??
         ((url) => new WsWebSocket(url, authToken ? { headers: { Authorization: `Bearer ${authToken}` } } : undefined));
-    const currentStatus = opts.currentStatus ??
-        (() => findSessionStatus(listTeamSessions(createStatusTracker()), session));
+    const tracker = createStatusTracker();
+    const currentStatus = opts.currentStatus ?? (() => findSessionStatus(listTeamSessions(tracker), session));
     const url = canonicalDaemonUrl("ws", info.bindHostname, info.port, "/ws/events");
     let socket;
     try {
@@ -85,9 +112,12 @@ export async function waitForAgentStatusViaReceipts(session, want, opts = {}) {
     }
     return new Promise((resolve) => {
         let settled = false;
+        let subscribed = false;
+        let ready = false;
         let lastStatus = null;
         let deadlineTimer = null;
         let connectTimer = null;
+        let refreshTimer = null;
         const settle = (result) => {
             if (settled)
                 return;
@@ -96,6 +126,8 @@ export async function waitForAgentStatusViaReceipts(session, want, opts = {}) {
                 clearTimeout(connectTimer);
             if (deadlineTimer !== null)
                 clearTimeout(deadlineTimer);
+            if (refreshTimer !== null)
+                clearTimeout(refreshTimer);
             try {
                 socket.close();
             }
@@ -104,30 +136,26 @@ export async function waitForAgentStatusViaReceipts(session, want, opts = {}) {
             }
             resolve(result);
         };
-        connectTimer = setTimeout(() => settle(null), connectTimeoutMs);
-        connectTimer.unref?.();
-        socket.on("error", () => settle(null));
-        socket.on("close", () => settle(null));
-        socket.on("open", () => {
+        const refreshStatus = () => {
             if (settled)
                 return;
-            if (connectTimer !== null)
-                clearTimeout(connectTimer);
-            deadlineTimer = setTimeout(() => settle({ ok: false, session, want, status: lastStatus, timedOutAfterMs: timeoutMs }), timeoutMs);
-            deadlineTimer.unref?.();
-            // The watcher baselines when the first client connects, so a receipt can
-            // only describe a transition AFTER this socket exists. Answer the
-            // already-finished case with one direct read.
             try {
                 lastStatus = currentStatus();
             }
             catch {
-                lastStatus = null;
+                // This transport cannot establish aggregate status; use the fallback.
+                settle(null);
+                return;
             }
-            if (lastStatus === want) {
+            if (lastStatus === want)
                 settle({ ok: true, session, want, status: want });
-            }
-        });
+        };
+        deadlineTimer = setTimeout(() => settle({ ...timedOut(), status: lastStatus }), remaining());
+        deadlineTimer.unref?.();
+        connectTimer = setTimeout(() => settle(null), connectTimeoutMs);
+        connectTimer.unref?.();
+        socket.on("error", () => settle(null));
+        socket.on("close", () => settle(null));
         socket.on("message", (data) => {
             if (settled)
                 return;
@@ -139,15 +167,66 @@ export async function waitForAgentStatusViaReceipts(session, want, opts = {}) {
                 return; // not a protocol frame — ignore
             }
             const parsed = DaemonEventServerFrameSchemaZ.safeParse(raw);
-            if (!parsed.success)
+            if (!parsed.success) {
+                if (!ready)
+                    settle(null); // incompatible handshake/protocol
                 return;
+            }
             const frame = parsed.data;
-            if (frame.type !== "agent.turn-completed" || frame.sessionName !== session)
+            if (frame.type === "protocol.error") {
+                settle(null);
                 return;
-            lastStatus = frame.toStatus;
-            if (frame.toStatus === want) {
-                settle({ ok: true, session, want, status: want });
             }
+            if (frame.type === "hello") {
+                if (subscribed)
+                    return;
+                if (frame.daemon.protocolVersion !== info.protocolVersion ||
+                    frame.daemon.instanceId !== info.instanceId) {
+                    settle(null);
+                    return;
+                }
+                subscribed = true;
+                try {
+                    socket.send(JSON.stringify({
+                        type: "subscribe",
+                        sessions: [],
+                        legacyEvents: true,
+                        interests: [{ resource: "fleet-catalog", workspaceName: null }],
+                        interestRevision: 1,
+                    }));
+                }
+                catch {
+                    settle(null);
+                }
+                return;
+            }
+            if (frame.type === "resource.interests-ack") {
+                if (!subscribed || ready || frame.interestRevision !== 1)
+                    return;
+                if (frame.unavailableInterests.length > 0) {
+                    settle(null);
+                    return;
+                }
+                ready = true;
+                if (connectTimer !== null)
+                    clearTimeout(connectTimer);
+                // Observation is installed and baselined before this read. Hints that
+                // arrived before the barrier are covered by this current snapshot.
+                refreshStatus();
+                return;
+            }
+            if (!ready)
+                return;
+            if ((frame.type !== "agent.turn-completed" && frame.type !== "agent-status.changed") ||
+                frame.sessionName !== session)
+                return;
+            if (refreshTimer !== null)
+                return;
+            refreshTimer = setTimeout(() => {
+                refreshTimer = null;
+                refreshStatus();
+            }, 0);
+            refreshTimer.unref?.();
         });
     });
 }

package/packages/daemon/src/command-center/agent-status-watch.ts

@@ -105,6 +105,10 @@ export interface AgentTurnCompletion {
  * Completed turns between two readings: panes present in BOTH whose state word
  * left `working` for `done` or `idle`. A pane that vanished mid-turn completed
  * nothing; a pane that appeared already-done transitioned nothing we observed.
+ * The durable stamp must remain equal: gaining, losing or replacing it is not
+ * evidence that the replacement completed the prior turn. Two unstamped reads
+ * retain anonymous receipts for compatibility, without process/task correlation.
+ * These sampled status transitions do not prove submitted-task success.
  * Sorted (session, then pane key) for deterministic emission order.
  */
 export function diffTurnCompletions(
@@ -119,11 +123,13 @@ export function diffTurnCompletions(
     for (const paneId of [...panes.keys()].sort()) {
       const prior = before.get(paneId);
       if (prior === undefined || agentStateWord(prior.state) !== "working") continue;
-      const word = agentStateWord(panes.get(paneId)!.state);
+      const current = panes.get(paneId)!;
+      if (prior.paneStamp !== current.paneStamp) continue;
+      const word = agentStateWord(current.state);
       if (word !== "done" && word !== "idle") continue;
       completions.push({
         sessionName,
-        paneStamp: panes.get(paneId)!.paneStamp,
+        paneStamp: current.paneStamp,
         fromStatus: "working",
         toStatus: word,
       });

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));
+    },
+  );
+}