tmux-ide 2.9.10 → 2.9.12

package/packages/daemon/dist/tui/mirror/runtime/application-terminal-interaction-controller.js

@@ -1,3 +1,5 @@
+import { rendererProbe } from "./renderer-probe.js";
+import { createTerminalSelectionWaiter } from "./terminal-selection-waiter.js";
 import { WorkspaceWindowLinkSelectResultSchemaZ } from "@tmux-ide/contracts";
 import { windowLinkForPane, windowLinkTarget } from "./application-terminal-workspace-policy.js";
 import { createHash, randomUUID } from "node:crypto";
@@ -117,6 +119,10 @@ export function createApplicationTerminalInteractionController(options) {
         left.generation === right.generation &&
         left.workspace === right.workspace;
     let selectedControl = null;
+    const selectionWaiter = createTerminalSelectionWaiter();
+    let observedLayoutEpoch = null;
+    let selectionGeneration = null;
+    let selectionLayout = options.layout();
     const waitingInput = new Set();
     let waitingInputBytes = 0;
     let releasingInput = null;
@@ -522,8 +528,28 @@ export function createApplicationTerminalInteractionController(options) {
     const paneInput = new TerminalPaneInputRouter({
         select: async (paneId) => {
             finishLinkSelection(false);
+            const initial = options.generation();
+            const selectionControl = controlIdentity(initial);
+            const selectionVersion = paneInput.selectionVersion;
+            const selectionCurrent = () => paneInput.selectionVersion === selectionVersion &&
+                sameControl(selectionControl, controlIdentity(selectionGeneration));
+            const panePresent = () => selectionLayout.windows.some((window) => window.panes.some((pane) => pane.pane === paneId));
+            if (initial?.status === "rebinding") {
+                // Reserve the optimistic target now, but send its FIRST mutation only
+                // after this same control connection has a coherent terminal runtime.
+                const ready = await selectionWaiter.wait(() => {
+                    if (!selectionCurrent())
+                        return false;
+                    const active = selectionGeneration;
+                    if (active?.status !== "live" || observedLayoutEpoch !== active.rendererEpoch)
+                        return "pending";
+                    return panePresent();
+                });
+                if (!ready || !selectionCurrent())
+                    return false;
+            }
             const expected = liveSelectionTarget();
-            const selectionControl = controlIdentity(options.generation());
+            let dispatchedRendererEpoch;
             const selecting = pendingWindowSwitch;
             const operationId = selecting?.traceId;
             const selectionFailure = { current: null };
@@ -536,8 +562,36 @@ export function createApplicationTerminalInteractionController(options) {
                         : null;
                 }, paneId, operationId, (failure) => {
                     selectionFailure.current = failure;
-                }, windowLinkForPane(options.layout(), paneId) ?? undefined)
+                }, windowLinkForPane(options.layout(), paneId) ?? undefined, () => {
+                    dispatchedRendererEpoch = options.generation()?.rendererEpoch;
+                })
                 : null;
+            if (receipt === null &&
+                selectionFailure.current?.reason === "topology-changed" &&
+                selectionCurrent()) {
+                // The daemon may have selected the pane before retiring its stream.
+                // Observe the replacement runtime; never resubmit an uncertain command
+                // or manufacture an operation receipt. Input still waits on this promise.
+                const confirmed = await selectionWaiter.wait(() => {
+                    if (!selectionCurrent())
+                        return false;
+                    const active = selectionGeneration;
+                    if (active?.status !== "live" ||
+                        active.rendererEpoch === dispatchedRendererEpoch ||
+                        observedLayoutEpoch !== active.rendererEpoch)
+                        return "pending";
+                    if (!panePresent())
+                        return false;
+                    const current = selectionLayout.current;
+                    const activePanes = current?.panes.filter((pane) => pane.active) ?? [];
+                    if (!current?.currentWindow || activePanes.length !== 1)
+                        return "pending";
+                    return activePanes[0]?.pane === paneId ? true : "pending";
+                });
+                if (selecting && pendingWindowSwitch === selecting)
+                    pendingWindowSwitch = null;
+                return confirmed && selectionCurrent();
+            }
             if (selecting && pendingWindowSwitch === selecting) {
                 const receiptAtMicros = options.detailedWindowSwitchTiming ? diagnosticNowMicros() : null;
                 if (selecting.timing)
@@ -685,22 +739,30 @@ export function createApplicationTerminalInteractionController(options) {
             }
             return outcome.status === "sent";
         },
-        onFocusedPane: options.setFocusedPane,
+        onFocusedPane: (pane) => {
+            rendererProbe()?.cancel("selection-changed", nowMicros());
+            options.setFocusedPane(pane);
+        },
     });
     return {
         cancelPendingInput() {
+            rendererProbe()?.cancel("input-cancelled", nowMicros());
+            selectionWaiter.cancel();
             finishLinkSelection(false);
             paneInput.invalidateSelection();
             for (const entry of waitingInput)
                 entry.settle(false);
         },
         adoptGeneration(snapshot) {
+            selectionGeneration = snapshot;
             const control = controlIdentity(snapshot);
             if (!sameControl(selectedControl, control)) {
+                rendererProbe()?.cancel("control-changed", nowMicros());
                 finishLinkSelection(false);
                 paneInput.invalidateSelection();
             }
             selectedControl = control;
+            selectionWaiter.reconcile();
             if (waitingInput.size > 0 && snapshot?.status === "live" && snapshot.fastLane) {
                 // Old waiters resume first; input admitted synchronously by the next
                 // layout publication must not overtake them in this microtask turn.
@@ -751,6 +813,7 @@ export function createApplicationTerminalInteractionController(options) {
                     next.fastLane !== inputAuthorityIdentity.fastLane ||
                     next.adapter !== inputAuthorityIdentity.adapter);
             if (next === null || replaced) {
+                rendererProbe()?.cancel("generation-changed", nowMicros());
                 finishLinkSelection(false);
                 pendingWindowSwitch = null;
                 pendingWindowRename = null;
@@ -764,6 +827,9 @@ export function createApplicationTerminalInteractionController(options) {
             inputAuthorityIdentity = next;
         },
         adoptLayout(snapshot) {
+            selectionLayout = snapshot;
+            observedLayoutEpoch = snapshot.rendererEpoch ?? null;
+            selectionWaiter.reconcile();
             reconcileLinkSelection(snapshot);
             paneInput.adoptCanonicalPane(snapshot.current ? paneForWindow(snapshot.current) : null);
             const currentWindow = snapshot.current?.semanticWindowId ?? snapshot.current?.windowName;
@@ -850,6 +916,7 @@ export function createApplicationTerminalInteractionController(options) {
         selectPane: (paneId) => {
             finishLinkSelection(false);
             paneInput.selectPane(paneId);
+            selectionWaiter.reconcile();
         },
         async unlinkWindowLink(target) {
             const expected = liveSelectionTarget();
@@ -979,9 +1046,27 @@ export function createApplicationTerminalInteractionController(options) {
             }
         },
         sendInput: async (input, parserOrigin) => {
-            await paneInput.sendInput({ input, parserOrigin });
+            const probe = rendererProbe();
+            const state = probe
+                ? (options.generation()?.fastLane?.lane.paneState(paneInput.focusedPane ?? "") ?? null)
+                : null;
+            const measured = probe?.admit(input, state, nowMicros());
+            const sent = await paneInput.sendInput({ input: measured ?? input, parserOrigin });
+            if (measured && !sent)
+                probe?.cancel("dispatch-rejected", nowMicros());
+        },
+        sendInputToPane: async (paneId, input, parserOrigin) => {
+            const probe = rendererProbe();
+            const state = probe ? (options.generation()?.fastLane?.lane.paneState(paneId) ?? null) : null;
+            const measured = probe?.admit(input, state, nowMicros());
+            const sent = await paneInput.sendInputToPane(paneId, {
+                input: measured ?? input,
+                parserOrigin,
+            });
+            if (measured && !sent)
+                probe?.cancel("dispatch-rejected", nowMicros());
+            return sent;
         },
-        sendInputToPane: (paneId, input, parserOrigin) => paneInput.sendInputToPane(paneId, { input, parserOrigin }),
         beginResizePointerIngress(input) {
             if (!options.diagnosticsEnabled)
                 return null;

package/packages/daemon/dist/tui/mirror/runtime/application-terminal-workspace.jsx

@@ -1,3 +1,4 @@
+import { rendererProbe } from "./renderer-probe.js";
 import { paneInteractionDisplayDestination } from "../ui/pane-interaction-presentation.js";
 import { interactionPaneEndpointKey } from "@tmux-ide/core";
 import { interactionForCurrentPane } from "../ui/pane-interaction-presentation.js";
@@ -935,6 +936,7 @@ export function ApplicationTerminalWorkspace(props) {
             return;
         }
         if (event.type === "scroll") {
+            const probeAt = rendererProbe() ? Math.floor(performance.now() * 1000) : 0;
             // A held selection owns the gesture even when the pointer crosses a sibling.
             const activeSelection = selecting;
             const selectionCell = activeSelection &&
@@ -942,7 +944,9 @@ export function ApplicationTerminalWorkspace(props) {
             const hit = activeSelection && selectionCell
                 ? { frame: activeSelection.frame, ...selectionCell }
                 : paneContentAt(point);
-            const before = props.onWheelObservation && hit ? scrollback.offset(hit.frame.paneId) : null;
+            const before = (props.onWheelObservation || rendererProbe()) && hit
+                ? scrollback.offset(hit.frame.paneId)
+                : null;
             const observe = (route) => {
                 props.onWheelObservation?.({
                     paneId: hit?.frame.paneId ?? null,
@@ -1021,6 +1025,14 @@ export function ApplicationTerminalWorkspace(props) {
                 }
                 else
                     scrollback.move(hit.frame.paneId, motion.lines);
+                if (rendererProbe() && identity && before !== null)
+                    rendererProbe()?.scroll({
+                        pane: hit.frame.paneId,
+                        generation: identity.generation,
+                        incarnation: identity.incarnation,
+                        cols: snapshot.cols,
+                        rows: snapshot.rows,
+                    }, snapshot, before, scrollback.offset(hit.frame.paneId), probeAt);
                 observe("local-history");
                 if (selecting?.paneId === hit.frame.paneId)
                     updatePointerSelection(selecting.pointer);

package/packages/daemon/dist/tui/mirror/runtime/open-tui-generation-host.js

@@ -371,7 +371,7 @@ export function createOpenTuiGenerationHost(sessionName, presentation, overrides
             // desired state against the fresh socket on the following live publish.
             publish({ ...snapshot, status: "rebinding" });
             owner.stopPresentation?.();
-            owner.stopPresentation = runtime ? presentation.adopt(runtime) : null;
+            owner.stopPresentation = runtime ? presentation.adopt(runtime, rendererEpoch + 1) : null;
             owner.runtime = runtime;
             owner.authorityClient = runtime ? runtimeAuthorityClient(owner.bundle, runtime) : null;
             if (!runtime)
@@ -394,7 +394,7 @@ export function createOpenTuiGenerationHost(sessionName, presentation, overrides
         if (candidate !== owner)
             return;
         if (runtime) {
-            owner.stopPresentation = presentation.adopt(runtime);
+            owner.stopPresentation = presentation.adopt(runtime, rendererEpoch + 1);
             diagnose?.("host-internal-snapshot-publication", {
                 publicationPhase: "presentation-adopted",
                 daemonGeneration: owner.bundle.connection.target.daemon.instanceId,

package/packages/daemon/dist/tui/mirror/runtime/renderer-probe.js

@@ -0,0 +1,195 @@
+import { visibleTerminalRowAt } from "../semantic-pane-render-source.js";
+import { appendFile } from "node:fs/promises";
+import { isAbsolute } from "node:path";
+function scope(state) {
+    return state.snapshot
+        ? {
+            pane: state.semanticPaneId,
+            generation: state.generation,
+            incarnation: state.incarnation,
+            cols: state.snapshot.cols,
+            rows: state.snapshot.rows,
+        }
+        : null;
+}
+const key = (s) => JSON.stringify([s.pane, s.generation, s.incarnation, s.cols, s.rows]);
+export class RendererProbe {
+    trials;
+    emit;
+    #next = 0;
+    #pending = null;
+    constructor(trials, emit) {
+        this.trials = trials;
+        this.emit = emit;
+        if (trials.length > 64 ||
+            new Set(trials.map((t) => t.nonce)).size !== trials.length ||
+            trials.some((t) => !t.id ||
+                t.id.length > 128 ||
+                !/^[a-f0-9]{32}$/.test(t.nonce) ||
+                (t.kind !== undefined && !["input", "scroll", "output"].includes(t.kind))))
+            throw new Error("Invalid renderer probe trials");
+    }
+    get pending() {
+        return this.#pending !== null;
+    }
+    admit(input, state, at) {
+        if (input.kind !== "text" ||
+            input.data !== "!" ||
+            !state?.snapshot ||
+            this.#pending ||
+            !this.trials[this.#next])
+            return null;
+        if (this.trials[this.#next]?.kind === "scroll")
+            return { kind: "text", data: `PROBE-PREPARE-SCROLL:${this.trials[this.#next].nonce}\n` };
+        const trial = this.trials[this.#next++], marker = `PROBE-OUTPUT:${trial.nonce}`, identity = scope(state);
+        this.#pending = { trial, scope: identity, at, marker, offset: 0, sourceOffset: 0 };
+        if (state.snapshot.cols < marker.length ||
+            state.snapshot.grid.some((r) => r.cells
+                .map((c) => c.grapheme)
+                .join("")
+                .includes(marker))) {
+            this.cancel("negative-control", at);
+            return null;
+        }
+        return {
+            kind: "text",
+            data: `${trial.kind === "output" ? "PROBE-BURST" : "PROBE-IN"}:${trial.nonce}\n`,
+        };
+    }
+    scroll(identity, snapshot, before, after, at) {
+        const trial = this.trials[this.#next];
+        if (this.#pending || trial?.kind !== "scroll" || before === after)
+            return;
+        const row = visibleTerminalRowAt(snapshot, after, 0);
+        const text = row?.cells
+            .map((c) => c.grapheme)
+            .join("")
+            .trimEnd() ?? "";
+        if (!new RegExp(`^PROBE-ROW:${trial.nonce}:[0-9]{4}$`).test(text))
+            return;
+        for (let y = 0; y < snapshot.rows; y++)
+            if (visibleTerminalRowAt(snapshot, before, y)
+                ?.cells.map((c) => c.grapheme)
+                .join("")
+                .trimEnd() === text)
+                return;
+        this.#next++;
+        this.#pending = {
+            trial,
+            scope: identity,
+            at,
+            marker: text,
+            offset: after,
+            sourceOffset: before,
+        };
+    }
+    tick(at) {
+        if (this.#pending && at - this.#pending.at > 5_000_000)
+            this.cancel("timeout", at);
+    }
+    cancel(reason, at) {
+        const p = this.#pending;
+        if (!p)
+            return;
+        this.#pending = null;
+        this.emit({
+            ...p.trial,
+            side: "tui",
+            kind: p.trial.kind ?? "input",
+            sourceScope: p.scope,
+            expectedScope: p.scope,
+            sourceOffset: p.sourceOffset,
+            expectedOffset: p.offset,
+            admittedAtMicros: p.at,
+            completedAtMicros: at,
+            endpoint: "input-admission-to-renderer-work-complete",
+            status: "failed",
+            reason,
+        });
+    }
+    observe(state, at) {
+        if (!this.#pending)
+            return;
+        if (state && state.semanticPaneId !== this.#pending.scope.pane)
+            return;
+        if (!state || !scope(state) || key(scope(state)) !== key(this.#pending.scope))
+            this.cancel("scope-changed", at);
+        else if (at - this.#pending.at > 5_000_000)
+            this.cancel("timeout", at);
+    }
+    row(state, row, viewportRow, width, height, left, scrollOffset, at) {
+        this.observe(state, at);
+        const p = this.#pending;
+        if (!p || state.semanticPaneId !== p.scope.pane)
+            return;
+        if (scrollOffset !== p.offset ||
+            left !== 0 ||
+            viewportRow !== 0 ||
+            height < 1 ||
+            width < p.marker.length ||
+            !row)
+            return;
+        const cells = row.cells.slice(0, p.marker.length);
+        if (cells.some((c) => c.width !== 1) || cells.map((c) => c.grapheme).join("") !== p.marker)
+            return;
+        if (!Number.isSafeInteger(at) || at < p.at) {
+            this.cancel("clock-invalid", at);
+            return;
+        }
+        this.#pending = null;
+        this.emit({
+            ...p.trial,
+            side: "tui",
+            kind: p.trial.kind ?? "input",
+            sourceScope: p.scope,
+            expectedScope: p.scope,
+            sourceOffset: p.sourceOffset,
+            expectedOffset: p.offset,
+            admittedAtMicros: p.at,
+            completedAtMicros: at,
+            endpoint: "input-admission-to-renderer-work-complete",
+            status: "completed",
+            durationMicros: at - p.at,
+            witness: {
+                row: viewportRow,
+                column: 0,
+                marker: p.marker,
+                revision: state.revision,
+                stateHash: state.hash,
+            },
+        });
+    }
+}
+let singleton;
+/** All filesystem work is asynchronous and deferred; at most64 short receipts. */
+export function rendererProbe() {
+    if (singleton !== undefined)
+        return singleton;
+    singleton = null;
+    if (process.env.TMUX_IDE_RENDERER_FIXTURE !== "1")
+        return null;
+    const raw = process.env.TMUX_IDE_RENDERER_PROBE_TRIALS, path = process.env.TMUX_IDE_RENDERER_PROBE_LOG;
+    if (!raw || raw.length > 16384 || !path || !isAbsolute(path))
+        return null;
+    try {
+        const trials = JSON.parse(raw);
+        if (!Array.isArray(trials))
+            return null;
+        let writes = Promise.resolve(), failed = false;
+        singleton = new RendererProbe(trials, (record) => {
+            if (failed)
+                return;
+            writes = writes
+                .then(() => appendFile(path, JSON.stringify(record) + "\n", { mode: 0o600 }))
+                .catch(() => {
+                failed = true;
+            });
+        });
+        const timer = setInterval(() => singleton?.tick(Math.floor(performance.now() * 1000)), 250);
+        timer.unref();
+    }
+    catch {
+        singleton = null;
+    }
+    return singleton;
+}

package/packages/daemon/dist/tui/mirror/runtime/runtime-layout-presentation.js

@@ -52,7 +52,7 @@ export function createOpenTuiRuntimeLayoutPresentation() {
             listener(windows);
             return () => windowListeners.delete(listener);
         },
-        adopt(port) {
+        adopt(port, rendererEpoch) {
             if (disposed)
                 return () => undefined;
             let candidate = true;
@@ -60,15 +60,18 @@ export function createOpenTuiRuntimeLayoutPresentation() {
             candidateStop = port.onLayout((layout) => {
                 if (disposed || !candidate || !layout.current)
                     return;
+                // A port may reuse its snapshot object. Own the provenance wrapper so
+                // a preparing runtime cannot relabel the retained coherent frame.
+                const presented = Object.freeze({ ...layout, rendererEpoch });
                 if (currentPort !== port) {
                     const previousStop = stopLayout;
                     currentPort = port;
                     stopLayout = candidateStop;
-                    publish(layout);
+                    publish(presented);
                     previousStop?.();
                     return;
                 }
-                publish(layout);
+                publish(presented);
             });
             // `onLayout` intentionally seeds synchronously. Capture the disposer
             // after that first callback has promoted this candidate.

package/packages/daemon/dist/tui/mirror/runtime/select-terminal-pane.js

@@ -1,5 +1,5 @@
 /** Acquire controller authority before issuing the canonical pane-select intent. */
-export async function selectTerminalPane(expected, current, semanticPaneId, operationId, onFailure, windowLink) {
+export async function selectTerminalPane(expected, current, semanticPaneId, operationId, onFailure, windowLink, onDispatch) {
     const fail = (failure) => {
         try {
             onFailure?.(failure);
@@ -20,7 +20,11 @@ export async function selectTerminalPane(expected, current, semanticPaneId, oper
             : undefined;
         return fail({
             stage,
-            reason: code === "operation-timeout" ? "operation-timeout" : "transport-rejected",
+            reason: code === "operation-timeout"
+                ? "operation-timeout"
+                : code === "topology-changed" && stage === "dispatch"
+                    ? "topology-changed"
+                    : "transport-rejected",
             ...(backendReason ? { backendReason } : {}),
         });
     };
@@ -50,6 +54,7 @@ export async function selectTerminalPane(expected, current, semanticPaneId, oper
             return fail({ stage: "pre-dispatch", reason: "generation-replaced" });
         let result;
         try {
+            onDispatch?.();
             result = await expected.client.dispatch({
                 kind: "semantic-intent",
                 ...(operationId ? { operationId } : {}),

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

@@ -1,3 +1,4 @@
+import { rendererProbe } from "./renderer-probe.js";
 import { terminalReplicaRowsEqual } from "@tmux-ide/core";
 import { reflowTerminalPosition, reflowRetainedTerminalSnapshot, retainNativeTerminalBacking, } from "../terminal-viewport.js";
 import { blitSemanticRow, changedTerminalRows, visibleTerminalRowAt, } from "../semantic-pane-render-source.js";
@@ -481,6 +482,8 @@ export class TerminalFastLaneRendererAdapter {
         if (interest.retainedView && next)
             this.#resizeRetainedView(interest, next);
         interest.state = publication.state;
+        if (rendererProbe()?.pending)
+            rendererProbe()?.observe(publication.state, Math.floor(performance.now() * 1000));
         // Preserve coordinates for an unchanged prefix or an exact retained suffix.
         // The suffix offset is fixed by the length difference; never search repeated
         // log lines for a guessed overlap. Changed grids/reflow need a separate map.
@@ -810,6 +813,9 @@ export class TerminalFastLaneRendererAdapter {
             if (interest?.dirtyRows.has(canonicalRow))
                 paintedCanonicalChange = true;
             blit(sourceRow, buffers, row, width, defaultFg, defaultBg, options.graphemes, options.palette, options.viewportOrigin?.x ?? 0);
+            if (interest?.state && rendererProbe()?.pending) {
+                rendererProbe()?.row(interest.retainedView?.state ?? interest.state, sourceRow, row, width, height, options.viewportOrigin?.x ?? 0, options.viewportOrigin ? Math.max(0, -options.viewportOrigin.y) : scrollOffset, Math.floor(performance.now() * 1_000));
+            }
             options.dirtyRows.push(row);
             paintedRows[row] = sourceRow;
         }

package/packages/daemon/dist/tui/mirror/runtime/terminal-selection-waiter.js

@@ -0,0 +1,36 @@
+/** One bounded selection observation; never submits or repeats a mutation. */
+export function createTerminalSelectionWaiter() {
+    let pending = null;
+    const cancel = () => pending?.finish(false);
+    const reconcile = () => {
+        const waiting = pending;
+        if (!waiting)
+            return;
+        const result = waiting.check();
+        if (result !== "pending")
+            waiting.finish(result);
+    };
+    return {
+        cancel,
+        reconcile,
+        wait(check) {
+            cancel();
+            return new Promise((resolve) => {
+                const timer = setTimeout(() => waiting.finish(false), 5000);
+                timer.unref?.();
+                const waiting = {
+                    check,
+                    finish(selected) {
+                        if (pending !== waiting)
+                            return;
+                        pending = null;
+                        clearTimeout(timer);
+                        resolve(selected);
+                    },
+                };
+                pending = waiting;
+                reconcile();
+            });
+        },
+    };
+}

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

@@ -95,6 +95,10 @@ export class SemanticPaneReplica {
             : [...this.#dirtyRows].sort((a, b) => a - b);
     }
     accept(message) {
+        if (message.type === "terminal.projection") {
+            this.#fail("protocol-violation", message.transactionId);
+            return;
+        }
         if (message.type === "terminal.delivery.fault") {
             this.#assembler = null;
             this.#snapshot = null;

package/packages/daemon/src/lib/daemon-embed.ts

@@ -8,7 +8,8 @@ import { createGuardedNativeSplitResize } from "./guarded-native-split-resize.ts
 import { WindowLinkTargetSchemaZ } from "@tmux-ide/contracts";
 import { WindowSplitLayoutUnavailable } from "../terminal/mirror/window-split-authority.ts";
 import { requireSupportedTmuxVersion } from "./tmux-version.ts";
-import { join } from "node:path";
+import { dirname, join } from "node:path";
+import { LocalImageOwner, cleanupLocalImageOwner } from "../terminal/graphics/local-image-owner.ts";
 import { createClaudeTeamMembershipReader } from "../terminal/attachments/claude-team-names.ts";
 import { PaneSourceDiscovery } from "./pane-source-discovery.ts";
 import { createBackgroundNativeCapture } from "./background-native-capture.ts";
@@ -159,6 +160,7 @@ import { captureDaemonProvenance } from "./daemon-provenance.ts";
 import { registerLogSecret, setLogIdentity } from "./log.ts";
 import {
   canonicalDaemonUrl,
+  getCanonicalDaemonInfoPath,
   clearCanonicalDaemonInfoIfOwned,
   clearCanonicalDaemonInfoIfUnchanged,
   inspectCanonicalDaemonInfo,
@@ -1399,6 +1401,7 @@ async function startEmbeddedDaemonGeneration(
     };
     let terminalAttachmentRuntime: NativeTerminalAttachmentRuntime | null = null;
     let paneStreamRuntime: PaneStreamRuntime | null = null;
+    let localImages: LocalImageOwner | undefined;
     let serverOwners: Awaited<ReturnType<typeof createEmbeddedTmuxServerOwners>> | null = null;
     let defaultEditorContextRetired = false;
     const defaultDiagnosticsLifetime = new AbortController();
@@ -1732,7 +1735,34 @@ async function startEmbeddedDaemonGeneration(
       };
       const peekTerminalAttachmentRuntime = (): NativeTerminalAttachmentRuntime | null =>
         terminalAttachmentRuntime;
+      // The held canonical claim has already proven and hardened this private root.
+      // Local images are optional: unavailable storage retains inline graphics.
+      if (process.platform !== "win32") {
+        const root = dirname(getCanonicalDaemonInfoPath());
+        try {
+          if (existingCanonical.status === "valid") {
+            await cleanupLocalImageOwner({
+              root,
+              owner: {
+                generation: existingCanonical.info.instanceId,
+                pid: existingCanonical.info.pid,
+                startedAt: existingCanonical.info.startedAt,
+              },
+              proveDead: () => isCanonicalDaemonRecordOwnerProvenDead(existingCanonical),
+            });
+          }
+          localImages = await LocalImageOwner.create({
+            root,
+            generation: instanceId,
+            pid: process.pid,
+            startedAt,
+          });
+        } catch {
+          localImages = undefined;
+        }
+      }
       paneStreamRuntime = createPaneStreamRuntime({
+        localImages,
         daemonInstanceId: instanceId,
         webSocketUrl: paneStreamWebSocketUrl(bindHostname, port),
         sessionRuntimeRegistry,
@@ -1758,6 +1788,7 @@ async function startEmbeddedDaemonGeneration(
       });
       await externalInteractionObserver.start();
       serverOwners = await createEmbeddedTmuxServerOwners({
+        localImages,
         environmentId,
         onDefaultScope: async (scope) => {
           interactionEvidence = new InteractionEvidenceAuthority(environmentId, scope);
@@ -2075,7 +2106,10 @@ async function startEmbeddedDaemonGeneration(
       // The pane-stream coordinator may still hold runtime consumers while it
       // drains. Preserve the normal shutdown order on startup rollback too:
       // transports first, then the one session/control authority.
-      await Promise.allSettled([sessionRuntimeRegistry?.dispose() ?? Promise.resolve()]);
+      await Promise.allSettled([
+        sessionRuntimeRegistry?.dispose() ?? Promise.resolve(),
+        localImages?.dispose() ?? Promise.resolve(),
+      ]);
       throw error;
     }
     const {
@@ -2108,6 +2142,7 @@ async function startEmbeddedDaemonGeneration(
         )),
         ...(await retirePaneStreamTransport()),
       ];
+      await localImages?.dispose();
       terminalInventoryRuntime.dispose();
       const paneDisposal = Promise.resolve().then(() => workspacePaneCreation.dispose());
       const workspaceOpenDisposal = Promise.resolve().then(() => workspaceOpen.dispose());
@@ -2375,6 +2410,7 @@ async function startEmbeddedDaemonGeneration(
               )),
             );
             failures.push(...(await retirePaneStreamTransport()));
+            await capture(() => localImages?.dispose());
             await capture(() => terminalInventoryRuntime.dispose());
             await capture(() => workspacePaneCreation.dispose());
             await capture(() => workspaceOpen.dispose());

package/packages/daemon/src/lib/embedded-tmux-server-owners.ts

@@ -1,3 +1,4 @@
+import type { LocalImageOwner } from "../terminal/graphics/local-image-owner.ts";
 import type { Server, IncomingMessage } from "node:http";
 import type { Socket } from "node:net";
 import { randomUUID } from "node:crypto";
@@ -22,6 +23,7 @@ import {
 
 /** Adapts the established default owner without duplicating its control clients. */
 export async function createEmbeddedTmuxServerOwners(options: {
+  readonly localImages?: LocalImageOwner;
   readonly environmentId: string;
   readonly onDefaultScope?: (scope: TmuxServerScope) => Promise<void>;
   readonly defaultAuthority: WorkspacePaneTmuxAuthority;
@@ -89,6 +91,7 @@ export async function createEmbeddedTmuxServerOwners(options: {
       if (registration.serverId === defaultRegistration.serverId) await retireDefault();
       const route = tmuxServerPaneStreamPath(scope);
       const owner = await createNativeTmuxServerOwner({
+        localImages: options.localImages,
         environmentId: options.environmentId,
         ...scope,
         tmuxAuthority: observation.authority,