tmux-ide 2.9.3 → 2.9.5

package/packages/daemon/dist/tui/integrations/claude-agent-teams.js

@@ -0,0 +1,264 @@
+/**
+ * Claude Code agent teams — opt-out enablement in the user's Claude settings.
+ *
+ * Agent teams let one Claude Code session spawn teammates; with
+ * `teammateMode: "auto"` Claude puts them in split panes when it runs inside
+ * tmux (in-process elsewhere), which is exactly what tmux-ide shows and
+ * routes. The installer enables this by default and `tmux-ide integration
+ * agent-teams enable|disable|status` manages it explicitly.
+ *
+ * Rules (pure, in {@link mergeAgentTeams}):
+ * - `env.CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS` is set to "1" only when absent.
+ *   An explicit off value ("0", "false", false, 0…) is the user's opt-out: the
+ *   installer never overrides it and touches nothing else. Only an explicit
+ *   `tmux-ide integration agent-teams enable` (overrideOptOut) turns it back on.
+ * - `teammateMode: "auto"` is set only when `teammateMode` is absent.
+ * - Every other key is preserved. Nothing changed → nothing written.
+ *
+ * Writes (io) reuse the hooks integration's settings path resolution, including
+ * the `TMUX_IDE_CLAUDE_SETTINGS` override: one-time timestamped backup before
+ * the first modification, then an atomic temp-file + rename. Invalid JSON is
+ * reported and never rewritten.
+ */
+import { chmodSync, existsSync, mkdirSync, readFileSync, readdirSync, renameSync, statSync, copyFileSync, unlinkSync, writeFileSync, accessSync, constants, } from "node:fs";
+import { basename, delimiter, dirname, join } from "node:path";
+import { resolveRuntimeNamespace, runtimeOwnedPath } from "../../lib/runtime-namespace.js";
+export const AGENT_TEAMS_ENV = "CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS";
+export const DEFAULT_TEAMMATE_MODE = "auto";
+const BACKUP_INFIX = ".tmux-ide-backup-";
+/** PURE — an explicit off value is the user's opt-out. */
+export function isOptOut(value) {
+    if (value === false || value === 0)
+        return true;
+    return typeof value === "string" && /^\s*(0|false|off|no)\s*$/iu.test(value);
+}
+function envOf(settings) {
+    const env = settings.env;
+    if (env === undefined)
+        return undefined;
+    if (!env || typeof env !== "object" || Array.isArray(env))
+        throw new Error("settings env must be an object");
+    return env;
+}
+/** PURE — how the settings currently stand for agent teams. */
+export function agentTeamsSetting(settings) {
+    const value = envOf(settings)?.[AGENT_TEAMS_ENV];
+    if (value === undefined)
+        return "not-configured";
+    return isOptOut(value) ? "disabled-by-user" : "enabled";
+}
+/**
+ * PURE — enable agent teams without overriding anything the user chose, unless
+ * `overrideOptOut` (the user explicitly asked to enable) replaces their "0".
+ */
+export function mergeAgentTeams(settings, { overrideOptOut = false } = {}) {
+    const setting = agentTeamsSetting(settings);
+    if (setting === "disabled-by-user" && !overrideOptOut)
+        return { settings, changes: [], setting };
+    const changes = [];
+    let next = settings;
+    if (setting !== "enabled") {
+        next = { ...next, env: { ...(envOf(settings) ?? {}), [AGENT_TEAMS_ENV]: "1" } };
+        changes.push(`env.${AGENT_TEAMS_ENV}=1`);
+    }
+    if (!("teammateMode" in settings)) {
+        next = { ...next, teammateMode: DEFAULT_TEAMMATE_MODE };
+        changes.push(`teammateMode=${DEFAULT_TEAMMATE_MODE}`);
+    }
+    return { settings: next, changes, setting: "enabled" };
+}
+/** PURE — record an explicit opt-out ("0"), which later enables respect. */
+export function disableAgentTeams(settings) {
+    if (agentTeamsSetting(settings) === "disabled-by-user")
+        return { settings, changes: [], setting: "disabled-by-user" };
+    return {
+        settings: { ...settings, env: { ...(envOf(settings) ?? {}), [AGENT_TEAMS_ENV]: "0" } },
+        changes: [`env.${AGENT_TEAMS_ENV}=0`],
+        setting: "disabled-by-user",
+    };
+}
+export function agentTeamsPaths() {
+    const namespace = resolveRuntimeNamespace();
+    return { settingsPath: namespace.claudeSettingsPath, claudeDir: namespace.claudeDir };
+}
+/** `claude` on PATH, without spawning anything. */
+export function claudeOnPath(path = process.env.PATH ?? "") {
+    return path
+        .split(delimiter)
+        .filter(Boolean)
+        .some((dir) => {
+        try {
+            accessSync(join(dir, "claude"), constants.X_OK);
+            return statSync(join(dir, "claude")).isFile();
+        }
+        catch {
+            return false;
+        }
+    });
+}
+export class InvalidClaudeSettingsError extends Error {
+}
+function readSettings(path) {
+    if (!existsSync(path))
+        return { settings: {}, exists: false };
+    try {
+        const parsed = JSON.parse(readFileSync(path, "utf8"));
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+            throw new Error("not an object");
+        envOf(parsed);
+        return { settings: parsed, exists: true };
+    }
+    catch {
+        throw new InvalidClaudeSettingsError(`${path} is not valid settings JSON — fix or move it, then retry`);
+    }
+}
+/** Existing one-time backup, if tmux-ide already made one for this file. */
+function existingBackup(settingsPath) {
+    const dir = dirname(settingsPath);
+    const prefix = `${basename(settingsPath)}${BACKUP_INFIX}`;
+    try {
+        const found = readdirSync(dir).find((name) => name.startsWith(prefix));
+        return found ? join(dir, found) : null;
+    }
+    catch {
+        return null;
+    }
+}
+function writeSettings(path, settings, exists) {
+    mkdirSync(dirname(path), { recursive: true });
+    let backup = null;
+    if (exists) {
+        backup = existingBackup(path);
+        if (!backup) {
+            const stamp = new Date()
+                .toISOString()
+                .replace(/[-:]/gu, "")
+                .replace(/\.\d+Z$/u, "Z");
+            backup = `${path}${BACKUP_INFIX}${stamp}`;
+            copyFileSync(path, backup);
+        }
+    }
+    const temporary = join(dirname(path), `.${basename(path)}.tmux-ide-${process.pid}.tmp`);
+    try {
+        writeFileSync(temporary, `${JSON.stringify(settings, null, 2)}\n`, { mode: 0o600 });
+        if (exists)
+            chmodSync(temporary, statSync(path).mode & 0o777);
+        renameSync(temporary, path);
+    }
+    catch (error) {
+        try {
+            unlinkSync(temporary);
+        }
+        catch {
+            /* already renamed or never written */
+        }
+        throw error;
+    }
+    return backup;
+}
+function detected(paths, onPath) {
+    return existsSync(paths.claudeDir) || onPath();
+}
+function guarded(paths) {
+    if (!paths && resolveRuntimeNamespace().development)
+        throw new Error("Development agent-teams changes require explicit fixture paths");
+    const resolved = paths ?? agentTeamsPaths();
+    runtimeOwnedPath(resolved.settingsPath);
+    return resolved;
+}
+/** Enable agent teams when Claude Code is installed and the user hasn't opted out. */
+export function enableClaudeAgentTeams(paths, onPath = () => claudeOnPath(), { overrideOptOut = false } = {}) {
+    const resolved = guarded(paths);
+    const { settingsPath } = resolved;
+    const base = { settingsPath, changes: [], backup: null };
+    if (!detected(resolved, onPath))
+        return {
+            ...base,
+            action: "skipped",
+            claudeDetected: false,
+            message: `Claude Code not found (no ${resolved.claudeDir}, no claude on PATH); agent teams not configured.`,
+        };
+    let read;
+    try {
+        read = readSettings(settingsPath);
+    }
+    catch (error) {
+        return { ...base, action: "invalid", claudeDetected: true, message: error.message };
+    }
+    const merged = mergeAgentTeams(read.settings, { overrideOptOut });
+    if (merged.setting === "disabled-by-user")
+        return {
+            ...base,
+            action: "disabled-by-user",
+            claudeDetected: true,
+            message: `Claude Code agent teams are disabled by user in ${settingsPath} (${AGENT_TEAMS_ENV}); ` +
+                "left unchanged. Enable explicitly: tmux-ide integration agent-teams enable",
+        };
+    if (merged.changes.length === 0)
+        return {
+            ...base,
+            action: "unchanged",
+            claudeDetected: true,
+            message: `Claude Code agent teams already enabled in ${settingsPath}.`,
+        };
+    const backup = writeSettings(settingsPath, merged.settings, read.exists);
+    return {
+        settingsPath,
+        changes: merged.changes,
+        backup,
+        action: "enabled",
+        claudeDetected: true,
+        message: `Enabled Claude Code agent teams in ${settingsPath} (${merged.changes.join(", ")}` +
+            `${backup ? `; backup: ${backup}` : ""}). Disable: tmux-ide integration agent-teams disable`,
+    };
+}
+/** Record the user's opt-out so neither the installer nor `enable` turns it back on silently. */
+export function disableClaudeAgentTeams(paths) {
+    const resolved = guarded(paths);
+    const { settingsPath } = resolved;
+    const base = { settingsPath, changes: [], backup: null, claudeDetected: true };
+    let read;
+    try {
+        read = readSettings(settingsPath);
+    }
+    catch (error) {
+        return { ...base, action: "invalid", message: error.message };
+    }
+    const next = disableAgentTeams(read.settings);
+    if (next.changes.length === 0)
+        return {
+            ...base,
+            action: "unchanged",
+            message: `Claude Code agent teams already disabled in ${settingsPath}.`,
+        };
+    const backup = writeSettings(settingsPath, next.settings, read.exists);
+    return {
+        ...base,
+        changes: next.changes,
+        backup,
+        action: "disabled",
+        message: `Disabled Claude Code agent teams in ${settingsPath} (${next.changes.join(", ")}` +
+            `${backup ? `; backup: ${backup}` : ""}). Re-enable: tmux-ide integration agent-teams enable`,
+    };
+}
+export function claudeAgentTeamsStatus(paths = agentTeamsPaths(), onPath = () => claudeOnPath()) {
+    const claudeDetected = detected(paths, onPath);
+    try {
+        const { settings } = readSettings(paths.settingsPath);
+        const mode = settings.teammateMode;
+        return {
+            settingsPath: paths.settingsPath,
+            claudeDetected,
+            setting: agentTeamsSetting(settings),
+            teammateMode: typeof mode === "string" ? mode : null,
+        };
+    }
+    catch {
+        return {
+            settingsPath: paths.settingsPath,
+            claudeDetected,
+            setting: "invalid-settings",
+            teammateMode: null,
+        };
+    }
+}

package/packages/daemon/dist/tui/mirror/open-tui-workspace-runtime-port.js

@@ -1,3 +1,4 @@
+import { STOCK_CAPTURE_TAB_UNAVAILABLE } from "@tmux-ide/contracts";
 import { randomUUID } from "node:crypto";
 import { TerminalDeliveryAssembler, decodeVerifiedCompactSemanticTerminalUpdate, decodeVerifiedCompactSemanticTerminalUpdateCooperatively, decodeVerifiedLegacySemanticTerminalUpdate, terminalDeliveryEncodingAccepted, } from "@tmux-ide/core";
 import { PaneStreamOperationError, } from "@tmux-ide/daemon-client/pane-stream-client";
@@ -193,7 +194,10 @@ function updateFromDelivery(envelope, payload, canonicalSnapshot, cols, rows) {
         stateHash: envelope.canonicalStateHash,
         hashAlgorithm: "fnv1a64-v1",
     };
-    if (payload.frame === "seed") {
+    // Wire patches may span skipped revisions; ordinary canonical patches may not.
+    // Publish the fully verified resulting state at its actual revision.
+    if (payload.frame === "seed" ||
+        (payload.frame === "patch" && payload.revision > payload.baseRevision + 1)) {
         return Object.freeze({
             ...common,
             type: "terminal.seed",
@@ -245,6 +249,7 @@ class WireTerminalEndpoint {
     #resolveReady;
     #readySettled = false;
     #hasCanonicalSeed = false;
+    #unavailable = null;
     constructor(options) {
         this.#workspaceName = options.workspaceName;
         this.#semanticPaneId = options.semanticPaneId;
@@ -272,8 +277,11 @@ class WireTerminalEndpoint {
         this.#readySettled = true;
         this.#resolveReady(true);
     }
+    get settled() {
+        return this.#unavailable !== null || this.inputReady;
+    }
     get inputReady() {
-        return !this.#closed && this.#hasCanonicalSeed && !this.#reseedRequired;
+        return (!this.#closed && this.#unavailable === null && this.#hasCanonicalSeed && !this.#reseedRequired);
     }
     async subscription() {
         const ready = await this.#ready;
@@ -291,6 +299,8 @@ class WireTerminalEndpoint {
                 this.#subscription = null;
         });
         this.#subscription = subscription;
+        if (this.#unavailable)
+            subscription.unavailable(this.#unavailable);
         return subscription;
     }
     accept(message) {
@@ -301,10 +311,30 @@ class WireTerminalEndpoint {
             return;
         }
         if (message.type === "terminal.delivery.fault") {
+            if (message.deliveryNonce !== this.#negotiated.deliveryNonce) {
+                this.#failConnection(new Error("Terminal fault nonce does not match negotiation"));
+                return;
+            }
+            // The exact shared diagnostic is currently the compatibility-preserving discriminator.
+            if (message.reason === "source-closed" && message.message === STOCK_CAPTURE_TAB_UNAVAILABLE) {
+                this.#unavailable = message.message;
+                this.#decodeToken = null;
+                this.#assembler = null;
+                this.#assemblyStorage = null;
+                this.#envelope = null;
+                this.#pending = null;
+                this.#canonicalSnapshot = null;
+                this.#hasCanonicalSeed = false;
+                this.#subscription?.unavailable(message.message);
+                this.#canonicalSeedReady();
+                return;
+            }
             const detail = message.message.trim();
             this.#failConnection(new Error(`Terminal delivery failed for ${this.#semanticPaneId}: ${message.reason}${detail ? ` (${detail})` : ""}`));
             return;
         }
+        if (this.#unavailable)
+            return;
         if (message.type === "terminal.delivery") {
             this.#acceptEnvelope(message);
             return;
@@ -601,6 +631,35 @@ class WireTerminalSubscription {
     #didClose;
     frozen = false;
     closed = false;
+    #unavailable = null;
+    #unavailableListeners = new Set();
+    onUnavailable(listener) {
+        if (this.closed)
+            return () => { };
+        this.#unavailableListeners.add(listener);
+        if (this.#unavailable) {
+            try {
+                listener(this.#unavailable);
+            }
+            catch {
+                /* Availability observers cannot interrupt sibling delivery. */
+            }
+        }
+        return () => this.#unavailableListeners.delete(listener);
+    }
+    unavailable(message) {
+        if (this.closed)
+            return;
+        this.#unavailable = message;
+        for (const listener of [...this.#unavailableListeners]) {
+            try {
+                listener(message);
+            }
+            catch {
+                /* Availability observers cannot interrupt sibling delivery. */
+            }
+        }
+    }
     constructor(generation, flush, didClose) {
         this.generation = generation;
         this.#flush = flush;
@@ -635,6 +694,7 @@ class WireTerminalSubscription {
             return;
         this.closed = true;
         this.#listeners.clear();
+        this.#unavailableListeners.clear();
         this.#didClose();
     }
 }
@@ -1170,7 +1230,7 @@ export async function connectOpenTuiWorkspaceRuntimePort(options) {
             });
             return request.result;
         }
-        if ([...endpoints.values()].some((endpoint) => !endpoint.inputReady))
+        if ([...endpoints.values()].some((endpoint) => !endpoint.settled))
             return Promise.resolve("geometry-authority-conflict");
         return (semanticWindowId === undefined
             ? opened.fitViewport(cols, rows)
@@ -1219,7 +1279,7 @@ export async function connectOpenTuiWorkspaceRuntimePort(options) {
             // until a different topology may be current; fail closed during seeding.
             if (closed ||
                 !latestLayoutSnapshot.windowLinks ||
-                [...endpoints.values()].some((endpoint) => !endpoint.inputReady))
+                [...endpoints.values()].some((endpoint) => !endpoint.settled))
                 throw new Error("Terminal inventory is still receiving canonical state");
             return (await opened.submitIntent(operationId, intent)) ?? undefined;
         },

package/packages/daemon/dist/tui/mirror/pane-surface.jsx

@@ -496,7 +496,16 @@ class PaneSurfaceRenderable extends FrameBufferRenderable {
         }
         if (this._needsWalk) {
             this._needsWalk = false;
-            this.walk();
+            try {
+                this.walk();
+            }
+            catch (error) {
+                // The source may have consumed its dirty rows before a grapheme or
+                // presentation pass fails. Rebuild the retained surface on retry.
+                this._needsWalk = true;
+                this._forceFull = true;
+                throw error;
+            }
         }
         else if (this._needsCursorPresentation) {
             this.applyCursorOnlyPresentation();

package/packages/daemon/dist/tui/mirror/reference-performance-trace.js

@@ -154,13 +154,13 @@ export function createReferenceTraceWriter(stream, options = {}) {
             firstDroppedRecord ??= droppedRecordKind(value);
             return;
         }
-        const line = `${JSON.stringify(value)}\n`;
-        const bytes = Buffer.byteLength(line);
-        if (bytes > MAX_TRACE_RECORD_BYTES) {
-            oversizedRecords += 1;
-            return;
-        }
         try {
+            const line = `${JSON.stringify(value)}\n`;
+            const bytes = Buffer.byteLength(line);
+            if (bytes > MAX_TRACE_RECORD_BYTES) {
+                oversizedRecords += 1;
+                return;
+            }
             if (!saturated && pendingCount() === 0) {
                 writeLine(line);
                 return;
@@ -233,7 +233,15 @@ export function createReferenceTraceWriter(stream, options = {}) {
     return Object.freeze({ append, appendCritical, snapshot, close });
 }
 function droppedRecordKind(value) {
-    const field = (key) => typeof value[key] === "string" ? value[key].slice(0, 64) : null;
+    const field = (key) => {
+        try {
+            const result = value[key];
+            return typeof result === "string" ? result.slice(0, 64) : null;
+        }
+        catch {
+            return null;
+        }
+    };
     return Object.freeze({
         type: field("type"),
         stage: field("stage"),
@@ -258,7 +266,12 @@ export function createReferencePerformanceTraceSink(options) {
     const inputs = new Map();
     let droppedInputs = 0;
     let closed = false;
-    const snapshot = () => Object.freeze({ pendingInputs: inputs.size, droppedInputs });
+    const attempts = { begun: 0, completed: 0, superseded: 0, expired: 0, cancelled: 0 };
+    const snapshot = () => Object.freeze({
+        pendingInputs: inputs.size,
+        droppedInputs,
+        inputAttempts: Object.freeze({ ...attempts, pending: inputs.size }),
+    });
     return Object.freeze({
         detailedWindowPresentationFrames: detailed ? true : undefined,
         frame: (intervalMs, window) => {
@@ -464,67 +477,79 @@ export function createReferencePerformanceTraceSink(options) {
             }
             : {}),
         beginTerminalInput: (origin) => {
-            const startedAtMicros = nowMicros();
-            expireInputs(inputs, startedAtMicros);
-            // The transport carries one latest-only performance trace id. Once a
-            // newer input is admitted, an older probe can no longer be attributed to
-            // the exact changed-cell paint without lying. Retire it as superseded;
-            // `droppedInputs` is reserved for actual capacity loss.
-            inputs.clear();
-            while (inputs.size >= MAX_PENDING_INPUTS) {
-                inputs.delete(inputs.keys().next().value);
-                droppedInputs += 1;
+            if (closed)
+                return Object.freeze({ traceId: "", finish: () => { }, cancel: () => { } });
+            attempts.begun += 1;
+            let traceId;
+            try {
+                const startedAtMicros = nowMicros();
+                attempts.expired += expireInputs(inputs, startedAtMicros);
+                // The transport carries one latest-only performance trace id. Once a
+                // newer input is admitted, an older probe can no longer be attributed to
+                // the exact changed-cell paint without lying. Retire it as superseded;
+                // `droppedInputs` is reserved for actual capacity loss.
+                attempts.superseded += inputs.size;
+                inputs.clear();
+                while (inputs.size >= MAX_PENDING_INPUTS) {
+                    inputs.delete(inputs.keys().next().value);
+                    droppedInputs += 1;
+                    attempts.cancelled += 1;
+                }
+                traceId = createTraceId();
+                if ((detailed || options.inputOrigin) &&
+                    origin &&
+                    !closed &&
+                    typeof options.inputFingerprintKey === "string" &&
+                    options.inputFingerprintKey.length >= 32) {
+                    const payload = Buffer.from(origin.payload);
+                    const event = {
+                        processId,
+                        clockId: "opentui-performance-now",
+                        clockKind: "performance-now",
+                        atMicros: Number.isSafeInteger(origin.ingressAtMicros) &&
+                            origin.ingressAtMicros <= startedAtMicros
+                            ? origin.ingressAtMicros
+                            : startedAtMicros,
+                        origin: origin.origin,
+                        payloadByteCount: payload.byteLength,
+                        payloadFingerprint: createHmac("sha256", options.inputFingerprintKey)
+                            .update(traceId)
+                            .update("\0")
+                            .update(payload)
+                            .digest("hex"),
+                        parserConsumption: origin.origin === "keyboard"
+                            ? "keyboard-event"
+                            : origin.origin === "bracketed-paste"
+                                ? "paste-event"
+                                : "pointer-event",
+                        ...(origin.gestureId ? { gestureId: origin.gestureId } : {}),
+                        ...(origin.pointerAction ? { pointerAction: origin.pointerAction } : {}),
+                        ...(Number.isSafeInteger(origin.pointerColumn)
+                            ? { pointerColumn: origin.pointerColumn }
+                            : {}),
+                        ...(Number.isSafeInteger(origin.pointerRow) ? { pointerRow: origin.pointerRow } : {}),
+                        ...(origin.pointerButton === null || Number.isSafeInteger(origin.pointerButton)
+                            ? { pointerButton: origin.pointerButton }
+                            : {}),
+                        traceId,
+                        semanticPaneId: origin.semanticPaneId,
+                        generation: origin.generation,
+                        incarnation: origin.incarnation,
+                        revision: origin.revision,
+                        stateHash: origin.stateHash,
+                    };
+                    options.append({ version: 1, type: "performance.input-origin", ...event });
+                }
+                inputs.set(traceId, {
+                    startedAtMicros,
+                    expiresAtMicros: startedAtMicros + INPUT_EXPIRY_MICROS,
+                    endedAtMicros: null,
+                });
             }
-            const traceId = createTraceId();
-            if ((detailed || options.inputOrigin) &&
-                origin &&
-                !closed &&
-                typeof options.inputFingerprintKey === "string" &&
-                options.inputFingerprintKey.length >= 32) {
-                const payload = Buffer.from(origin.payload);
-                const event = {
-                    processId,
-                    clockId: "opentui-performance-now",
-                    clockKind: "performance-now",
-                    atMicros: Number.isSafeInteger(origin.ingressAtMicros) &&
-                        origin.ingressAtMicros <= startedAtMicros
-                        ? origin.ingressAtMicros
-                        : startedAtMicros,
-                    origin: origin.origin,
-                    payloadByteCount: payload.byteLength,
-                    payloadFingerprint: createHmac("sha256", options.inputFingerprintKey)
-                        .update(traceId)
-                        .update("\0")
-                        .update(payload)
-                        .digest("hex"),
-                    parserConsumption: origin.origin === "keyboard"
-                        ? "keyboard-event"
-                        : origin.origin === "bracketed-paste"
-                            ? "paste-event"
-                            : "pointer-event",
-                    ...(origin.gestureId ? { gestureId: origin.gestureId } : {}),
-                    ...(origin.pointerAction ? { pointerAction: origin.pointerAction } : {}),
-                    ...(Number.isSafeInteger(origin.pointerColumn)
-                        ? { pointerColumn: origin.pointerColumn }
-                        : {}),
-                    ...(Number.isSafeInteger(origin.pointerRow) ? { pointerRow: origin.pointerRow } : {}),
-                    ...(origin.pointerButton === null || Number.isSafeInteger(origin.pointerButton)
-                        ? { pointerButton: origin.pointerButton }
-                        : {}),
-                    traceId,
-                    semanticPaneId: origin.semanticPaneId,
-                    generation: origin.generation,
-                    incarnation: origin.incarnation,
-                    revision: origin.revision,
-                    stateHash: origin.stateHash,
-                };
-                options.append({ version: 1, type: "performance.input-origin", ...event });
+            catch (error) {
+                attempts.cancelled += 1;
+                throw error;
             }
-            inputs.set(traceId, {
-                startedAtMicros,
-                expiresAtMicros: startedAtMicros + INPUT_EXPIRY_MICROS,
-                endedAtMicros: null,
-            });
             let finished = false;
             return Object.freeze({
                 traceId,
@@ -536,10 +561,19 @@ export function createReferencePerformanceTraceSink(options) {
                     if (input)
                         input.endedAtMicros = nowMicros();
                 },
-                cancel: () => inputs.delete(traceId),
+                cancel: () => {
+                    if (inputs.delete(traceId))
+                        attempts.cancelled += 1;
+                },
             });
         },
-        terminalTraceSpan: (paint) => recordCompletedTrace(inputs, paint, options.append),
+        terminalTraceSpan: (paint) => {
+            if (closed || paint.processId !== processId)
+                return;
+            const outcome = recordCompletedTrace(inputs, paint, options.append);
+            if (outcome)
+                attempts[outcome] += 1;
+        },
         terminalTraceStage: (event) => {
             if ((detailed || options.inputDetail) && !closed)
                 options.append({ version: 1, type: "performance.stage", ...event });
@@ -560,6 +594,7 @@ export function createReferencePerformanceTraceSink(options) {
             // Shutdown cancels probes that can no longer observe a future paint.
             // They are not backpressure loss and must not survive as phantom work in
             // a closed collector summary.
+            attempts.cancelled += inputs.size;
             inputs.clear();
             return snapshot();
         },
@@ -568,10 +603,17 @@ export function createReferencePerformanceTraceSink(options) {
 function recordCompletedTrace(inputs, paint, appendRecord) {
     const input = inputs.get(paint.traceId);
     if (!input || input.endedAtMicros === null)
-        return;
+        return null;
+    if (paint.clockId !== "opentui-performance-now" ||
+        paint.clockKind !== "performance-now" ||
+        !Number.isFinite(paint.startedAtMicros) ||
+        !Number.isFinite(paint.endedAtMicros) ||
+        paint.startedAtMicros < input.endedAtMicros ||
+        paint.endedAtMicros < paint.startedAtMicros)
+        return null;
     if (paint.startedAtMicros > input.expiresAtMicros) {
         inputs.delete(paint.traceId);
-        return;
+        return "expired";
     }
     inputs.delete(paint.traceId);
     appendRecord({
@@ -588,11 +630,15 @@ function recordCompletedTrace(inputs, paint, appendRecord) {
         authority: { generation: paint.generation, incarnation: paint.incarnation },
     });
     appendRecord({ version: 1, type: "performance.stage", ...paint });
+    return "completed";
 }
 function expireInputs(inputs, nowMicros) {
+    let expired = 0;
     for (const [traceId, input] of inputs) {
         if (input.expiresAtMicros > nowMicros)
             break;
         inputs.delete(traceId);
+        expired += 1;
     }
+    return expired;
 }