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

package/packages/daemon/dist/lib/soak-verdict.js

@@ -1,11 +1,4 @@
-/**
- * Pure analysis for the daemon soak harness (`packages/daemon/scripts/soak-daemon.mjs`).
- *
- * The harness records one JSONL sample per interval; this module turns the
- * sample series into a summary and a verdict against explicit thresholds. It
- * has no io and no dependencies so the harness can import it directly and the
- * numbers it prints are the numbers the colocated tests pin down.
- */
+import { MEMORY_KEYS, RESOURCE_KEYS, } from "./soak-diagnostics.js";
 export const DEFAULT_SOAK_THRESHOLDS = {
     maxRssGrowthMiBPerHour: 8,
     maxFdDrift: 16,
@@ -56,12 +49,25 @@ export function percentile(values, fraction) {
     const rank = Math.min(sorted.length - 1, Math.max(0, Math.ceil(fraction * sorted.length) - 1));
     return sorted[rank];
 }
+/** At most 228 buckets for probes capped at 60 seconds, plus an overflow bucket. */
 export function percentiles(values) {
-    return {
-        count: values.length,
-        p50: percentile(values, 0.5),
-        max: values.length === 0 ? null : Math.max(...values),
-    };
+    const buckets = {};
+    let max = null;
+    for (const value of values) {
+        if (!Number.isFinite(value) || value < 0)
+            continue;
+        max = Math.max(max ?? 0, value);
+        const index = value <= 1 ? 0 : Math.min(227, Math.ceil(Math.log(value) / Math.log(1.05)));
+        buckets[index] = (buckets[index] ?? 0) + 1;
+    }
+    return mergePercentiles([
+        {
+            count: Object.values(buckets).reduce((a, b) => a + b, 0),
+            p50: null,
+            max,
+            buckets,
+        },
+    ]);
 }
 /**
  * Fit a per-sample metric against elapsed time and report the slope per hour.
@@ -105,25 +111,83 @@ function maxValue(samples, pick) {
     }
     return max;
 }
-/**
- * Merge per-interval percentile records into a whole-run estimate. Exact
- * per-sample series are not retained across intervals, so the p50 here is the
- * count-weighted median of interval medians and the max is the true max.
- */
+/** Merge bounded histograms, never a median of medians. Legacy p50 is unmeasured. */
 export function mergePercentiles(records) {
-    const weighted = [];
-    let max = null;
+    const buckets = {};
     let count = 0;
+    let max = null;
+    let missing = false;
     for (const record of records) {
-        if (record.p50 === null || record.count === 0)
-            continue;
         count += record.count;
-        for (let index = 0; index < record.count; index += 1)
-            weighted.push(record.p50);
-        if (record.max !== null && (max === null || record.max > max))
-            max = record.max;
+        if (record.count && !record.buckets)
+            missing = true;
+        if (record.max !== null)
+            max = Math.max(max ?? 0, record.max);
+        for (const [key, value] of Object.entries(record.buckets ?? {}))
+            buckets[key] = (buckets[key] ?? 0) + value;
     }
-    return { count, p50: percentile(weighted, 0.5), max };
+    let cumulative = 0;
+    let p50 = null;
+    if (!missing && count) {
+        for (const key of Object.keys(buckets)
+            .map(Number)
+            .sort((a, b) => a - b)) {
+            cumulative += buckets[key];
+            if (cumulative >= Math.ceil(count / 2)) {
+                p50 = key === 227 ? max : Math.min(max ?? Infinity, 1.05 ** key);
+                break;
+            }
+        }
+    }
+    return { count, p50, max, buckets };
+}
+export function soakTrends(samples, warmupSeconds, trailingSeconds) {
+    const end = samples.at(-1)?.elapsedSeconds ?? 0;
+    const fit = (window) => ({
+        memoryMiBPerHour: Object.fromEntries(MEMORY_KEYS.map((key) => [
+            key,
+            growthPerHour(window, (s) => {
+                const value = s.diagnostics?.sample?.memory[key];
+                return value === undefined ? null : value / 1024 ** 2;
+            }),
+        ])),
+        activeResourcesPerHour: Object.fromEntries(RESOURCE_KEYS.map((key) => [
+            key,
+            growthPerHour(window, (s) => s.diagnostics?.sample?.activeResources?.[key] ?? null),
+        ])),
+        diagnosticCpuPercentPerHour: growthPerHour(window, (s) => s.diagnosticDelta?.status === "ok" ? s.diagnosticDelta.cpuPercent : null),
+        eventLoopUtilizationPerHour: growthPerHour(window, (s) => s.diagnosticDelta?.status === "ok" ? s.diagnosticDelta.eventLoopUtilization : null),
+        rssMiBPerHour: growthPerHour(window, (s) => (s.rssKiB === null ? null : s.rssKiB / 1024)),
+        cpuPercentPerHour: growthPerHour(window, (s) => s.cpuDeltaSeconds === null || s.intervalSeconds <= 0
+            ? null
+            : (100 * s.cpuDeltaSeconds) / s.intervalSeconds),
+        spawnsPerMinutePerHour: growthPerHour(window, (s) => s.intervalSeconds <= 0 ? null : (60 * s.tmuxSpawns) / s.intervalSeconds),
+    });
+    return {
+        whole: fit(samples),
+        afterWarmup: fit(samples.filter((s) => s.elapsedSeconds >= warmupSeconds)),
+        trailing: fit(samples.filter((s) => s.elapsedSeconds >= Math.max(warmupSeconds, end - trailingSeconds))),
+    };
+}
+/** Descriptive only: heap changes can reflect GC and do not prove retention. */
+export function summarizeDiagnostics(samples) {
+    const describe = (pick) => ({
+        start: firstValue(samples, pick),
+        end: lastValue(samples, pick),
+        max: maxValue(samples, pick),
+        measuredSamples: samples.filter((s) => pick(s) !== null).length,
+    });
+    return {
+        validSamples: samples.filter((s) => s.diagnostics?.status === "ok").length,
+        unsupportedResourceSamples: samples.filter((s) => s.diagnostics?.status === "ok" && s.diagnostics.sample.activeResources === null).length,
+        memoryBytes: Object.fromEntries(MEMORY_KEYS.map((key) => [key, describe((s) => s.diagnostics?.sample?.memory[key] ?? null)])),
+        activeResources: Object.fromEntries(RESOURCE_KEYS.map((key) => [
+            key,
+            describe((s) => s.diagnostics?.sample?.activeResources?.[key] ?? null),
+        ])),
+        cpuPercent: describe((s) => s.diagnosticDelta?.status === "ok" ? s.diagnosticDelta.cpuPercent : null),
+        eventLoopUtilization: describe((s) => s.diagnosticDelta?.status === "ok" ? s.diagnosticDelta.eventLoopUtilization : null),
+    };
 }
 export function summarizeSoak(samples) {
     const rss = (sample) => sample.rssKiB === null ? null : sample.rssKiB / KIB_PER_MIB;
@@ -149,6 +213,7 @@ export function summarizeSoak(samples) {
         disconnects += sample.unexpectedDisconnects;
     }
     return {
+        diagnostics: summarizeDiagnostics(samples),
         samples: samples.length,
         durationSeconds,
         rssStartMiB: firstValue(samples, rss),
@@ -183,9 +248,12 @@ function boundCheck(id, observed, bound, detail, options = {}) {
  * measure it (too few samples for a fit, a metric never collected); the
  * overall verdict is then `inconclusive` unless some other check failed.
  */
-export function evaluateSoak(samples, thresholds = DEFAULT_SOAK_THRESHOLDS) {
+export function evaluateSoak(samples, thresholds = DEFAULT_SOAK_THRESHOLDS, evidence) {
     const summary = summarizeSoak(samples);
-    const enoughForFit = samples.length >= thresholds.minSamplesForFit;
+    const enoughForFit = samples.length >= thresholds.minSamplesForFit &&
+        (!evidence ||
+            samples.filter((sample) => sample.elapsedSeconds >= evidence.warmupSeconds).length >=
+                thresholds.minSamplesForFit);
     const checks = [
         enoughForFit
             ? boundCheck("rss-growth", summary.rssGrowthMiBPerHour, thresholds.maxRssGrowthMiBPerHour, `fitted RSS slope MiB/h over ${samples.length} samples (r2 ${summary.rssFitR2?.toFixed(2) ?? "n/a"})`)
@@ -194,7 +262,7 @@ export function evaluateSoak(samples, thresholds = DEFAULT_SOAK_THRESHOLDS) {
                 ok: null,
                 observed: summary.rssGrowthMiBPerHour,
                 bound: thresholds.maxRssGrowthMiBPerHour,
-                detail: `needs ${thresholds.minSamplesForFit} samples, have ${samples.length}`,
+                detail: `needs ${thresholds.minSamplesForFit} samples and, when declared, post-warmup coverage; have ${samples.length} total`,
             },
         boundCheck("fd-drift", summary.fdStart === null || summary.fdEnd === null ? null : summary.fdEnd - summary.fdStart, thresholds.maxFdDrift, "open fd count end minus start", { absolute: true }),
         enoughForFit
@@ -204,15 +272,71 @@ export function evaluateSoak(samples, thresholds = DEFAULT_SOAK_THRESHOLDS) {
                 ok: null,
                 observed: summary.fdGrowthPerHour,
                 bound: thresholds.maxFdGrowthPerHour,
-                detail: `needs ${thresholds.minSamplesForFit} samples, have ${samples.length}`,
+                detail: `needs ${thresholds.minSamplesForFit} samples and, when declared, post-warmup coverage; have ${samples.length} total`,
             },
-        boundCheck("ping-rtt-p50", summary.pingRttMs.p50, thresholds.maxPingRttP50Ms, "events-client ping round-trip p50 ms"),
-        boundCheck("receipt-latency-p50", summary.receiptLatencyMs.p50, thresholds.maxReceiptLatencyP50Ms, "wait agent-status receipt latency p50 ms after the flip"),
+        boundCheck("ping-rtt-p50", summary.pingRttMs.p50, thresholds.maxPingRttP50Ms, "WebSocket transport control RTT p50 upper bound ms (not semantic handler latency)"),
+        boundCheck("receipt-latency-p50", summary.receiptLatencyMs.p50, thresholds.maxReceiptLatencyP50Ms, "wait agent-status receipt latency p50 upper bound ms after the flip"),
         boundCheck("observer-gaps", summary.observerGapWarnings, thresholds.maxObserverGapWarnings, "interaction observer gap warnings"),
         boundCheck("daemon-restarts", summary.daemonRestarts, thresholds.maxDaemonRestarts, "daemon pid or instance changes"),
         boundCheck("receipt-failures", summary.receiptFailures, thresholds.maxReceiptFailures, "receipt waiters that failed or timed out"),
         boundCheck("unexpected-disconnects", summary.unexpectedDisconnects, thresholds.maxUnexpectedDisconnects, "events-client drops outside scheduled reconnects"),
     ];
+    const coverage = (id, complete, detail) => checks.push({
+        id,
+        ok: complete === true ? true : null,
+        observed: complete === true ? 1 : null,
+        bound: 1,
+        detail,
+    });
+    coverage("duration-complete", evidence?.completed && evidence.observedSeconds >= evidence.requestedSeconds, "requested duration reached without interruption");
+    coverage("telemetry-complete", evidence?.telemetryComplete &&
+        samples.every((s) => [s.rssKiB, s.cpuSeconds, s.openFds].every((value) => value !== null && Number.isFinite(value))), "all required samples and metrics present");
+    coverage("diagnostics-coverage", samples.length > 0 &&
+        samples.every((s) => s.diagnostics?.status === "ok" && s.diagnostics.sample.activeResources !== null), "owner diagnostics and supported resource counts required at every sample; missing/malformed/404 remain inconclusive");
+    coverage("diagnostics-deltas", samples.length > 1 &&
+        samples.every((s, i) => i === 0
+            ? s.diagnosticDelta?.status === "missing-baseline"
+            : s.diagnosticDelta?.status === "ok" && s.diagnosticDelta.eventLoopUtilization !== null), "adjacent monotonic cumulative counters required after first baseline");
+    checks.push(boundCheck("diagnostics-identity", samples.filter((s) => s.diagnostics?.status === "identity-mismatch" ||
+        s.diagnosticDelta?.status === "identity-mismatch").length, 0, "diagnostics must match original daemon identity and PID"));
+    coverage("load-complete", evidence?.loadCompleted, "each declared workload completed at least once");
+    coverage("log-coverage", evidence?.logCoverageComplete, "continuous log stream, bookmark, no gap or replay ambiguity");
+    coverage("run-evidence", evidence !== undefined, "explicit run and teardown evidence supplied");
+    coverage("resource-trend-policy", evidence?.resourceTrendPolicyComplete, "heap/resources and CPU/spawn trend acceptance policy awaiting calibration and review");
+    if (evidence) {
+        const requiredFailures = [
+            "health",
+            "flip",
+            "promotion",
+            "send",
+            "receipt",
+            "daemonMissing",
+            "daemonExit",
+            "ack",
+            "pingDeadline",
+            "loop",
+            "sample",
+        ];
+        for (const name of new Set([...requiredFailures, ...Object.keys(evidence.failures)])) {
+            const count = evidence.failures[name];
+            checks.push(boundCheck(name, typeof count === "number" && Number.isFinite(count) && count >= 0 ? count : null, 0, "explicit run failure count"));
+        }
+        coverage("reconnect-coverage", evidence.reconnectAttempts > 1 &&
+            evidence.reconnectAttempts === evidence.reconnectAcknowledged, "initial subscription and at least one reconnect acknowledged");
+        for (const [id, ok] of [
+            ["shutdown-clean", evidence.shutdownClean],
+            ["record-retired", evidence.recordRetired],
+            ["cleanup-complete", evidence.cleanupComplete],
+        ])
+            checks.push({ id, ok, observed: ok ? 0 : 1, bound: 0, detail: "observed teardown outcome" });
+        const trends = soakTrends(samples, evidence.warmupSeconds, evidence.trailingSeconds);
+        for (const [window, metrics] of Object.entries(trends)) {
+            if (window === "whole")
+                continue;
+            const fit = metrics.rssMiBPerHour;
+            checks.push(boundCheck(`rss-${window}`, fit && fit.points >= thresholds.minSamplesForFit ? fit.slope : null, thresholds.maxRssGrowthMiBPerHour, "predeclared window RSS slope MiB/h"));
+        }
+    }
     const failed = checks.some((check) => check.ok === false);
     const unmeasured = checks.some((check) => check.ok === null);
     return {
@@ -298,11 +422,23 @@ export function formatSoakReport(result) {
         ["tmux spawns", `${summary.tmuxSpawnsTotal} total  ${num(summary.tmuxSpawnsPerMinute, 2)}/min`],
         [
             "ping rtt ms",
-            `p50 ${num(summary.pingRttMs.p50, 2)}  max ${num(summary.pingRttMs.max, 2)}  n ${summary.pingRttMs.count}`,
+            `p50 <= ${num(summary.pingRttMs.p50, 2)}  max ${num(summary.pingRttMs.max, 2)}  n ${summary.pingRttMs.count}`,
         ],
         [
             "receipt ms",
-            `p50 ${num(summary.receiptLatencyMs.p50, 0)}  max ${num(summary.receiptLatencyMs.max, 0)}  n ${summary.receiptLatencyMs.count}`,
+            `p50 <= ${num(summary.receiptLatencyMs.p50, 0)}  max ${num(summary.receiptLatencyMs.max, 0)}  n ${summary.receiptLatencyMs.count}`,
+        ],
+        [
+            "owner diagnostics",
+            `${summary.diagnostics.validSamples}/${summary.samples} valid; resources unsupported ${summary.diagnostics.unsupportedResourceSamples}`,
+        ],
+        [
+            "heap used MiB",
+            `start ${num(summary.diagnostics.memoryBytes.heapUsed?.start === null || summary.diagnostics.memoryBytes.heapUsed?.start === undefined ? null : summary.diagnostics.memoryBytes.heapUsed.start / 1024 ** 2)}  end ${num(summary.diagnostics.memoryBytes.heapUsed?.end === null || summary.diagnostics.memoryBytes.heapUsed?.end === undefined ? null : summary.diagnostics.memoryBytes.heapUsed.end / 1024 ** 2)} (descriptive; GC-sensitive)`,
+        ],
+        [
+            "diagnostic CPU",
+            `${num(summary.diagnostics.cpuPercent.start)} → ${num(summary.diagnostics.cpuPercent.end)} % interval; policy pending`,
         ],
         ["observer gaps", String(summary.observerGapWarnings)],
         ["daemon restarts", String(summary.daemonRestarts)],
@@ -320,3 +456,17 @@ export function formatSoakReport(result) {
     lines.push(`verdict: ${result.verdict.toUpperCase()}`);
     return lines.join("\n");
 }
+/** A revision acknowledges exactly the interest set sent in that subscribe. */
+export function validSoakAck(frame, revision) {
+    if (!frame || typeof frame !== "object")
+        return false;
+    const ack = frame;
+    return (ack.type === "resource.interests-ack" &&
+        ack.interestRevision === revision &&
+        Array.isArray(ack.unavailableInterests) &&
+        ack.unavailableInterests.length === 0);
+}
+/** Unsolicited/stale control payloads cannot discharge the current probe. */
+export function correlatedPongRtt(probe, payload, now) {
+    return payload === probe.id && Number.isFinite(now) && now >= probe.at ? now - probe.at : null;
+}

package/packages/daemon/dist/lib/terminal-host-color.js

@@ -0,0 +1,33 @@
+function color(red, green, blue) {
+    return { space: "srgb", red, green, blue, alpha: 255 };
+}
+export 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 color(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 color(channel(x11[1]), channel(x11[2]), channel(x11[3]));
+}
+/** Only a reported default background determines host appearance. */
+export function terminalHostMode(background) {
+    const value = parseTerminalHostColor(background);
+    return value
+        ? 0.299 * value.red + 0.587 * value.green + 0.114 * value.blue > 127.5
+            ? "light"
+            : "dark"
+        : null;
+}

package/packages/daemon/dist/tui/mirror/automatic-contrast.js

@@ -0,0 +1,161 @@
+/** Quantized sRGB contrast; Oklab matrices: https://bottosson.github.io/posts/oklab/ . */
+const LINEAR = Float64Array.from({ length: 256 }, (_, n) => {
+    const c = n / 255;
+    return c <= 0.04045 ? c / 12.92 : ((c + 0.055) / 1.055) ** 2.4;
+});
+const luminance = (rgb) => 0.2126 * LINEAR[(rgb >>> 16) & 255] +
+    0.7152 * LINEAR[(rgb >>> 8) & 255] +
+    0.0722 * LINEAR[rgb & 255];
+export function packedContrastRatio(a, b) {
+    const x = luminance(a) + 0.05, y = luminance(b) + 0.05;
+    return Math.max(x, y) / Math.min(x, y);
+}
+function byte(c) {
+    return Math.round(Math.max(0, Math.min(1, c <= 0.0031308 ? c * 12.92 : 1.055 * c ** (1 / 2.4) - 0.055)) * 255);
+}
+function candidate(L, a, b) {
+    // Reduce chroma along the same hue ray until inside sRGB, then quantize.
+    let lo = 0, hi = 1, result = -1;
+    for (let i = 0; i < 10; i++) {
+        const scale = i === 0 ? 1 : (lo + hi) / 2;
+        const l = (L + 0.3963377774 * a * scale + 0.2158037573 * b * scale) ** 3;
+        const m = (L - 0.1055613458 * a * scale - 0.0638541728 * b * scale) ** 3;
+        const s = (L - 0.0894841775 * a * scale - 1.291485548 * b * scale) ** 3;
+        const r = 4.0767416621 * l - 3.3077115913 * m + 0.2309699292 * s;
+        const g = -1.2684380046 * l + 2.6097574011 * m - 0.3413193965 * s;
+        const blue = -0.0041960863 * l - 0.7034186147 * m + 1.707614701 * s;
+        if (Math.min(r, g, blue) >= 0 && Math.max(r, g, blue) <= 1) {
+            result = (byte(r) << 16) | (byte(g) << 8) | byte(blue);
+            if (i === 0)
+                return result;
+            lo = scale;
+        }
+        else
+            hi = scale;
+    }
+    return result < 0 ? byte(L ** 3) * 0x10101 : result;
+}
+/** Leave passing pairs exact. Search both lightness directions with a verified endpoint fallback. */
+export function correctContrastForeground(fg, bg) {
+    if (packedContrastRatio(fg, bg) >= 4.5)
+        return fg;
+    const r = LINEAR[(fg >>> 16) & 255], g = LINEAR[(fg >>> 8) & 255], b = LINEAR[fg & 255];
+    const l = Math.cbrt(0.4122214708 * r + 0.5363325363 * g + 0.0514459929 * b);
+    const m = Math.cbrt(0.2119034982 * r + 0.6806995451 * g + 0.1073969566 * b);
+    const s = Math.cbrt(0.0883024619 * r + 0.2817188376 * g + 0.6299787005 * b);
+    const L = 0.2104542553 * l + 0.793617785 * m - 0.0040720468 * s;
+    const a = 1.9779984951 * l - 2.428592205 * m + 0.4505937099 * s;
+    const bb = 0.0259040371 * l + 0.7827717662 * m - 0.808675766 * s;
+    let best = 0, distance = Infinity;
+    for (const end of [0, 1]) {
+        let passing = end, failing = L;
+        let rgb = end === 0 ? 0 : 0xffffff;
+        if (packedContrastRatio(rgb, bg) < 4.5)
+            continue;
+        for (let i = 0; i < 12; i++) {
+            const mid = (passing + failing) / 2;
+            const trial = candidate(mid, a, bb);
+            if (packedContrastRatio(trial, bg) >= 4.5) {
+                passing = mid;
+                rgb = trial;
+            }
+            else
+                failing = mid;
+        }
+        if (Math.abs(passing - L) < distance) {
+            best = rgb;
+            distance = Math.abs(passing - L);
+        }
+    }
+    return best;
+}
+/** Cheap high-color-churn fallback: linear-sRGB blend to the nearer passing endpoint. */
+export function fastContrastForeground(fg, bg) {
+    if (packedContrastRatio(fg, bg) >= 4.5)
+        return fg;
+    const y = luminance(fg), base = luminance(bg);
+    const darkTarget = (base + 0.05) / 4.5 - 0.05;
+    const lightTarget = (base + 0.05) * 4.5 - 0.05;
+    const darkMix = darkTarget >= 0 ? (y - darkTarget) / y : Infinity;
+    const lightMix = lightTarget <= 1 ? (lightTarget - y) / (1 - y) : Infinity;
+    const end = darkMix <= lightMix ? 0 : 1;
+    // A small quantization margin usually avoids endpoint fallback. Always verify.
+    const amount = Math.min(1, Math.max(0, Math.min(darkMix, lightMix)) + 0.012);
+    const r = LINEAR[(fg >>> 16) & 255], g = LINEAR[(fg >>> 8) & 255], b = LINEAR[fg & 255];
+    const result = (byte(r + (end - r) * amount) << 16) |
+        (byte(g + (end - g) * amount) << 8) |
+        byte(b + (end - b) * amount);
+    return packedContrastRatio(result, bg) >= 4.5 ? result : end === 0 ? 0 : 0xffffff;
+}
+export function createContrastPairCache(limit = 4096) {
+    const pairs = new Map();
+    let remaining = Infinity;
+    return {
+        beginFrame() {
+            remaining = 128;
+        },
+        get size() {
+            return pairs.size;
+        },
+        correct(fg, bg) {
+            const key = fg * 0x1000000 + bg;
+            const cached = pairs.get(key);
+            if (cached !== undefined)
+                return cached;
+            const corrected = packedContrastRatio(fg, bg) >= 4.5
+                ? fg
+                : remaining-- > 0
+                    ? correctContrastForeground(fg, bg)
+                    : fastContrastForeground(fg, bg);
+            if (pairs.size >= limit)
+                pairs.clear();
+            pairs.set(key, corrected);
+            return corrected;
+        },
+    };
+}
+const read = (c, i) => ((c[i] & 255) << 16) | ((c[i + 1] & 255) << 8) | (c[i + 2] & 255);
+/** Final composed surface only: no canonical state or scheduling; allocation-free cache hits. */
+export function createAutomaticContrastPass() {
+    const cache = createContrastPairCache();
+    return (buffer) => {
+        cache.beginFrame();
+        const { char, fg, bg, attributes } = buffer.buffers;
+        for (let cell = 0; cell < char.length; cell++) {
+            const cp = char[cell], attr = attributes[cell], i = cell * 4;
+            // Preserve concealment, whitespace and pixel-art coverage. Grapheme IDs and
+            // wide continuations are opaque and retained byte-for-byte.
+            if (attr & 64 ||
+                cp === 0 ||
+                cp === 32 ||
+                cp === 160 ||
+                (cp >= 0x2580 && cp <= 0x259f) ||
+                (cp >= 0x2800 && cp <= 0x28ff))
+                continue;
+            if ((fg[i + 3] & 255) !== 255 || (bg[i + 3] & 255) !== 255)
+                continue;
+            const foreground = attr & 32 ? bg : fg;
+            const background = attr & 32 ? fg : bg;
+            const original = read(foreground, i);
+            const base = read(background, i);
+            // DIM is emulator-dependent. Materialize a deterministic 50% sRGB blend
+            // before correction and clear only the final composed DIM bit.
+            let visible = original;
+            if (attr & 2) {
+                visible =
+                    (Math.round(((original >>> 16) + (base >>> 16)) / 2) << 16) |
+                        (Math.round((((original >>> 8) & 255) + ((base >>> 8) & 255)) / 2) << 8) |
+                        Math.round(((original & 255) + (base & 255)) / 2);
+                attributes[cell] = attr & ~2;
+            }
+            const corrected = cache.correct(visible, base);
+            if (corrected === original && !(attr & 2))
+                continue;
+            // RGB intent is zero. Indexed/default metadata must not override correction.
+            foreground[i] = corrected >>> 16;
+            foreground[i + 1] = (corrected >>> 8) & 255;
+            foreground[i + 2] = corrected & 255;
+            foreground[i + 3] = 255;
+        }
+    };
+}

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

@@ -1124,7 +1124,7 @@ export async function connectOpenTuiWorkspaceRuntimePort(options) {
             }
         }) ?? null;
     let pendingInitialFit = null;
-    const fitViewport = (cols, rows) => {
+    const fitViewport = (cols, rows, semanticWindowId) => {
         if (closed)
             return Promise.resolve("geometry-authority-conflict");
         // Keep only the latest requested geometry while hidden seeds arrive. All
@@ -1133,23 +1133,29 @@ export async function connectOpenTuiWorkspaceRuntimePort(options) {
             if (pendingInitialFit) {
                 pendingInitialFit.cols = cols;
                 pendingInitialFit.rows = rows;
+                pendingInitialFit.semanticWindowId = semanticWindowId;
                 return pendingInitialFit.result;
             }
             const request = {
                 cols,
                 rows,
+                semanticWindowId,
                 result: Promise.resolve("geometry-authority-conflict"),
             };
             pendingInitialFit = request;
             request.result = allSeeds.then((ready) => {
                 pendingInitialFit = null;
-                return ready ? fitViewport(request.cols, request.rows) : "geometry-authority-conflict";
+                return ready
+                    ? fitViewport(request.cols, request.rows, request.semanticWindowId)
+                    : "geometry-authority-conflict";
             });
             return request.result;
         }
         if ([...endpoints.values()].some((endpoint) => !endpoint.inputReady))
             return Promise.resolve("geometry-authority-conflict");
-        return opened.fitViewport(cols, rows).catch((error) => {
+        return (semanticWindowId === undefined
+            ? opened.fitViewport(cols, rows)
+            : opened.fitViewport(cols, rows, semanticWindowId)).catch((error) => {
             if (error instanceof PaneStreamOperationError && error.code === "authority-rejected")
                 return "geometry-authority-conflict";
             throw error;

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

@@ -422,11 +422,11 @@ class PaneSurfaceRenderable extends FrameBufferRenderable {
         if (v === this._presentationGeneration)
             return;
         this._presentationGeneration = v;
-        // Framebuffer validity is independent from terminal content freshness. A
-        // quiet pane must be able to repaint its retained canonical snapshot after
-        // visibility/composition changes without waiting for another terminal byte.
-        this._forceFull = true;
-        this.invalidate();
+        // Composition reuses the retained framebuffer. Geometry reallocation,
+        // source replacement and palette changes independently force a full walk.
+        // Reclaim the hardware cursor at the new absolute position on visibility.
+        this._needsCursorPresentation = true;
+        this.requestRender();
     }
     set sourceEpoch(v) {
         if (v === this._sourceEpoch)
@@ -453,6 +453,8 @@ class PaneSurfaceRenderable extends FrameBufferRenderable {
             // Detailed focus correlation never owns renderer replacement.
         }
         this._rendererEpoch = v;
+        this._forceFull = true;
+        this.invalidate();
     }
     set hostFocusTransitionOwner(v) {
         if (v !== this._hostFocusTransitionOwner)