tmux-ide 2.9.11 → 2.9.13

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/command-center/resources/saved-machine-route.ts

@@ -1,3 +1,4 @@
+import { mountSavedMachineWatch } from "./saved-machine-watch.ts";
 import type { Hono } from "hono";
 import { bodyLimit } from "hono/body-limit";
 import { z } from "zod";
@@ -7,6 +8,7 @@ import {
   loadSavedMachines,
   mergeSavedMachines,
   updateSavedMachines,
+  watchSavedMachines,
 } from "../../lib/saved-machines.ts";
 import { ownerAuthorityGate } from "../owner-authority.ts";
 
@@ -26,8 +28,10 @@ export function mountSavedMachineRoute(
     read?: typeof loadSavedMachines;
     merge?: typeof mergeSavedMachines;
     update?: typeof updateSavedMachines;
+    watch?: typeof watchSavedMachines;
   },
 ) {
+  mountSavedMachineWatch(app, options);
   const authorize = ownerAuthorityGate(options.ownerToken, {
     whenOwnerless: "unavailable",
     unavailableMessage: "Machine registry unavailable",

package/packages/daemon/src/command-center/resources/saved-machine-watch.ts

@@ -0,0 +1,132 @@
+import { createHash } from "node:crypto";
+import type { Hono } from "hono";
+import { z } from "zod";
+import {
+  SavedMachineRegistrySchema,
+  type SavedMachineRegistry,
+  type DaemonInstanceIdentity,
+} from "@tmux-ide/contracts";
+import { loadSavedMachines, watchSavedMachines } from "../../lib/saved-machines.ts";
+import { ownerAuthorityGate } from "../owner-authority.ts";
+
+export const SAVED_MACHINE_WATCH_WAIT_MS = 20_000;
+const MAX_WATCHERS = 32;
+const Query = z.strictObject({
+  expectedInstanceId: z.uuid(),
+  after: z
+    .string()
+    .regex(/^[a-f0-9]{64}$/u)
+    .optional(),
+});
+type Snapshot = { revision: string; registry: SavedMachineRegistry };
+type Result =
+  | { status: 200; revision: string; registry: SavedMachineRegistry | null }
+  | { status: 408 | 503 };
+function snapshot(value: SavedMachineRegistry): Snapshot {
+  const registry = SavedMachineRegistrySchema.parse(value);
+  return {
+    registry,
+    revision: createHash("sha256").update(JSON.stringify(registry)).digest("hex"),
+  };
+}
+
+/** One bounded notification request. A new request always observes the latest registry. */
+export function mountSavedMachineWatch(
+  app: Hono,
+  options: {
+    daemon: DaemonInstanceIdentity;
+    ownerToken: string | null;
+    read?: typeof loadSavedMachines;
+    watch?: typeof watchSavedMachines;
+  },
+) {
+  const authorize = ownerAuthorityGate(options.ownerToken, {
+    whenOwnerless: "unavailable",
+    unavailableMessage: "Machine registry unavailable",
+    mismatchMessage: "Machine registry requires owner authority",
+  });
+  const read = options.read ?? loadSavedMachines;
+  const watch = options.watch ?? watchSavedMachines;
+  let active = 0;
+  app.get("/api/resources/saved-machines/watch", async (c) => {
+    const gate = authorize(c);
+    if (gate) return gate;
+    c.header("Cache-Control", "no-store");
+    const query = Query.safeParse(c.req.query());
+    if (!query.success) return c.json({ error: "Invalid registry watch request" }, 400);
+    if (query.data.expectedInstanceId !== options.daemon.instanceId)
+      return c.json({ error: "Daemon generation changed" }, 409);
+    if (active >= MAX_WATCHERS) return c.json({ error: "Registry watch capacity reached" }, 429);
+    active++;
+    try {
+      const initial = snapshot(read());
+      if (query.data.after !== initial.revision)
+        return c.json({ daemon: options.daemon, ...initial });
+      const signal = c.req.raw.signal;
+      const result = await new Promise<Result>((resolve) => {
+        let settled = false;
+        let stop = () => {};
+        const finish = (result: Result) => {
+          if (settled) return;
+          settled = true;
+          clearTimeout(timer);
+          signal.removeEventListener("abort", aborted);
+          try {
+            stop();
+          } finally {
+            resolve(result);
+          }
+        };
+        const aborted = () => finish({ status: 408 });
+        const timer = setTimeout(
+          () => finish({ status: 200, revision: initial.revision, registry: null }),
+          SAVED_MACHINE_WATCH_WAIT_MS,
+        );
+        timer.unref();
+        const changed = (value: SavedMachineRegistry) => {
+          if (settled) return;
+          try {
+            const next = snapshot(value);
+            if (next.revision !== initial.revision) finish({ status: 200, ...next });
+          } catch {
+            finish({ status: 503 });
+          }
+        };
+        signal.addEventListener("abort", aborted, { once: true });
+        if (signal.aborted) {
+          aborted();
+          return;
+        }
+        try {
+          stop = watch(changed, () => finish({ status: 503 }));
+          // Watch implementations may synchronously report an initial error/change.
+          if (settled) {
+            stop();
+            return;
+          }
+          // Close the read-before-subscribe race independently of watcher behavior.
+          changed(read());
+        } catch {
+          finish({ status: 503 });
+        }
+      });
+      if (result.status !== 200)
+        return c.json(
+          {
+            error:
+              result.status === 408 ? "Registry watch cancelled" : "Machine registry unavailable",
+          },
+          result.status,
+        );
+      return c.json({
+        daemon: options.daemon,
+        revision: result.revision,
+        registry: result.registry,
+      });
+    } catch {
+      return c.json({ error: "Machine registry unavailable" }, 503);
+    } finally {
+      active--;
+    }
+  });
+}

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

@@ -1,3 +1,4 @@
+import { TERMINAL_SURFACE_CAPABILITY_VERSION } from "@tmux-ide/contracts";
 import { mountAutomationRoutes } from "./automation.ts";
 import { mountTmuxServerRoutes } from "./tmux-servers.ts";
 import { streamBoundedLogs } from "./log-stream.ts";
@@ -197,6 +198,9 @@ export interface CreateAppOptions {
   /** Catalog + startup-barrier facts for the startup readiness ladder. */
   startupReadinessAttachmentBackend?: StartupReadinessAttachmentAuthority | null;
   paneStreamIssueBackend?: PaneStreamIssueBackend | null;
+  /** Current authenticated provider availability, never inferred from platform or PID. */
+  nativeSurfaceProviderAvailable?: () => boolean;
+  nativeSurfaceProviderSupported?: () => boolean;
   applicationShellInventoryBackend?: {
     discoverApplicationShellSession(
       requestedSessionName: string,
@@ -657,6 +661,20 @@ export function createApp(options: CreateAppOptions = {}): Hono {
         status: "ok" as const,
         daemon: daemonInstanceIdentity,
         capabilities: {
+          ...(c.req.query("nativeSurfaces") === "1"
+            ? {
+                nativeSurfaces: {
+                  supported:
+                    !!options.paneStreamIssueBackend &&
+                    options.nativeSurfaceProviderSupported?.() === true,
+                  available:
+                    options.paneStreamIssueBackend !== undefined &&
+                    options.paneStreamIssueBackend !== null &&
+                    options.nativeSurfaceProviderAvailable?.() === true,
+                  protocolVersion: TERMINAL_SURFACE_CAPABILITY_VERSION,
+                },
+              }
+            : {}),
           // Opt-in keeps the response compatible with older strict host schemas.
           ...(c.req.query("windowViewport") === "1"
             ? {

package/packages/daemon/src/command-center/tmux-servers.ts

@@ -1,3 +1,4 @@
+import { NativeSurfaceLocationSchema } from "../lib/native-surface-context.ts";
 import { mountTmuxServerHistoryAnchorRoute } from "./tmux-server-history-anchor.ts";
 import { mountTmuxServerDiagnosticsRoute } from "./tmux-server-diagnostics.ts";
 import { WindowSplitLayoutUnavailable } from "../terminal/mirror/window-split-authority.ts";
@@ -277,6 +278,19 @@ export function mountTmuxServerRoutes(app: Hono, options: TmuxServerRoutesOption
       );
     }),
   );
+  app.post(
+    `${scoped}/native-surface-context`,
+    route(async (c) => {
+      const server = scope(c);
+      const target = NativeSurfaceLocationSchema.parse(await boundedJson(c.req.raw, 8192));
+      c.req.raw.signal.throwIfAborted();
+      const context = await options.owners.withOwner(server, (owner) =>
+        owner.resolveNativeSurfaceContext(target, c.req.raw.signal),
+      );
+      c.req.raw.signal.throwIfAborted();
+      return c.json({ version: 1, server, context });
+    }),
+  );
   app.get(
     `${scoped}/inventory/:workspaceName`,
     route(async (c) => {

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

@@ -1,3 +1,5 @@
+import { createNativeSurfaceContextResolver } from "./native-surface-context.ts";
+import { NativeSurfaceProviderRegistry } from "../terminal/graphics/native-surface-provider.ts";
 import { TmuxServerVersionSchemaZ } from "@tmux-ide/contracts";
 import {
   createNativeSplitCapabilityProbe,
@@ -8,7 +10,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";
@@ -138,6 +141,7 @@ import {
   attachTerminalAttachmentWebSocket,
   type TerminalAttachmentWebSocketBoundary,
 } from "../server/terminal-attachment-upgrade.ts";
+import { attachNativeSurfaceProvider } from "../server/native-surface-provider-upgrade.ts";
 import {
   attachPaneStreamWebSocket,
   type PaneStreamWebSocketBoundary,
@@ -159,6 +163,7 @@ import { captureDaemonProvenance } from "./daemon-provenance.ts";
 import { registerLogSecret, setLogIdentity } from "./log.ts";
 import {
   canonicalDaemonUrl,
+  getCanonicalDaemonInfoPath,
   clearCanonicalDaemonInfoIfOwned,
   clearCanonicalDaemonInfoIfUnchanged,
   inspectCanonicalDaemonInfo,
@@ -918,6 +923,10 @@ async function startHttpServer({
       issue: (request, context) => getTerminalAttachmentRuntime().admission.issue(request, context),
     },
     paneStreamIssueBackend: paneStreamRuntime.coordinator,
+    nativeSurfaceProviderSupported: () =>
+      serverOwners.isDefaultCurrent() && paneStreamRuntime.nativeSurfaces !== undefined,
+    nativeSurfaceProviderAvailable: () =>
+      serverOwners.isDefaultCurrent() && paneStreamRuntime.nativeSurfaces?.available === true,
     applicationShellInventoryBackend: terminalInventoryRuntime,
     startupReadinessAttachmentBackend: terminalInventoryRuntime,
     catalogLiveSessions,
@@ -968,12 +977,26 @@ async function startHttpServer({
       (create ? getTerminalAttachmentRuntime() : peekTerminalAttachmentRuntime())?.admission ??
       null,
   );
-  const paneStreamBoundary = attachPaneStreamWebSocket(
+  const paneStreamSocketBoundary = attachPaneStreamWebSocket(
     server,
     paneStreamRuntime.coordinator,
     PANE_STREAM_REDEEM_PATH,
     () => serverOwners.isDefaultCurrent(),
   );
+  const nativeProviderBoundary = paneStreamRuntime.nativeSurfaces
+    ? attachNativeSurfaceProvider(
+        server,
+        paneStreamRuntime.nativeSurfaces,
+        localBypassToken ?? null,
+        () => serverOwners.isDefaultCurrent(),
+      )
+    : null;
+  const paneStreamBoundary: PaneStreamWebSocketBoundary = {
+    async close() {
+      nativeProviderBoundary?.close();
+      await paneStreamSocketBoundary.close();
+    },
+  };
   serverOwners.attach(server);
 
   try {
@@ -1399,6 +1422,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();
@@ -1523,6 +1547,8 @@ async function startEmbeddedDaemonGeneration(
         externalInteractionObserver.setDiagnostics(diagnostics);
         setFleetFactsObserverDiagnostics(diagnostics);
       }
+      const nativeSurfaces =
+        process.platform === "darwin" ? new NativeSurfaceProviderRegistry(instanceId) : undefined;
       sessionRuntimeRegistry = new SessionRuntimeRegistry({
         generation: instanceId,
         ...(runtimeObservability ? { observability: runtimeObservability } : {}),
@@ -1558,6 +1584,8 @@ async function startEmbeddedDaemonGeneration(
           publishResourceChange: (change) => broadcastResourceChanged(change, instanceId),
         },
         mirror: {
+          onNativeClientPresence: (session, present) =>
+            nativeSurfaces?.demand.presence(session, present),
           splitLayoutEpoch: () => observationSelector?.nativeServerEpoch ?? null,
           splitLayoutPrepare: createNativeSplitReadiness({
             observation: () => observationSelector ?? null,
@@ -1732,7 +1760,35 @@ 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({
+        nativeSurfaces,
+        localImages,
         daemonInstanceId: instanceId,
         webSocketUrl: paneStreamWebSocketUrl(bindHostname, port),
         sessionRuntimeRegistry,
@@ -1758,6 +1814,7 @@ async function startEmbeddedDaemonGeneration(
       });
       await externalInteractionObserver.start();
       serverOwners = await createEmbeddedTmuxServerOwners({
+        localImages,
         environmentId,
         onDefaultScope: async (scope) => {
           interactionEvidence = new InteractionEvidenceAuthority(environmentId, scope);
@@ -1849,6 +1906,22 @@ async function startEmbeddedDaemonGeneration(
             return grant ? interactionEvidence.captureSourceBinding(grant) : null;
           },
           interactionReceipts,
+          resolveNativeSurfaceContext: createNativeSurfaceContextResolver({
+            generation: instanceId,
+            registry: workspaceRegistry,
+            catalog: createNativeTmuxServerCatalog(workspaceRegistry, fleetFactsTmuxRunner),
+            inventory: terminalInventoryRuntime,
+            run: (args, signal) => fleetFactsTmuxRunner(args, signal),
+            assertOpen: () => {
+              if (
+                defaultEditorContextRetired ||
+                serverOwners?.defaultRetired ||
+                !initialNativeServerIdentity ||
+                terminalInventoryRuntime?.lifecycleState() !== "ready"
+              )
+                throw new Error("Default native surface context owner is unavailable");
+            },
+          }),
           resolvePaneEditorContext: createPaneEditorContextResolver({
             generation: instanceId,
             registry: workspaceRegistry,
@@ -2075,7 +2148,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 +2184,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 +2452,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,

package/packages/daemon/src/lib/native-surface-context.ts

@@ -0,0 +1,123 @@
+import { isAbsolute } from "node:path";
+import { z } from "zod";
+import {
+  TerminalAttachmentSemanticPaneIdSchemaZ,
+  WorkspaceCatalogLiveSessionIdSchemaZ,
+} from "@tmux-ide/contracts";
+import type { LiveSessionSummary } from "../command-center/discovery.ts";
+import type { WorkspaceTerminalInventoryRuntime } from "../terminal/attachments/native-runtime.ts";
+import type { WorkspaceRegistry } from "./workspace-registry.ts";
+
+export const NativeSurfaceLocationSchema = z
+  .object({
+    socketPath: z
+      .string()
+      .min(1)
+      .max(4096)
+      .refine((p) => isAbsolute(p) && !/[\0\r\n\t]/u.test(p)),
+    serverPid: z
+      .string()
+      .max(16)
+      .regex(/^[1-9][0-9]*$/u),
+    sessionId: z
+      .string()
+      .max(32)
+      .regex(/^\$(?:0|[1-9][0-9]*)$/u),
+    runtimePaneId: z
+      .string()
+      .max(32)
+      .regex(/^%(?:0|[1-9][0-9]*)$/u),
+  })
+  .strict();
+export type NativeSurfaceLocation = z.infer<typeof NativeSurfaceLocationSchema>;
+
+interface Options {
+  generation: string;
+  assertOpen(): void;
+  run(args: readonly string[], signal: AbortSignal): Promise<string>;
+  registry: Pick<WorkspaceRegistry, "get">;
+  catalog(): Promise<LiveSessionSummary[]>;
+  inventory: Pick<WorkspaceTerminalInventoryRuntime, "discoverTerminalInventory">;
+}
+
+/** Resolve inherited tmux location only through the current generation's pinned owner. */
+export function createNativeSurfaceContextResolver(options: Options) {
+  const generation = z.uuid().parse(options.generation);
+  return async (input: NativeSurfaceLocation, cancellation?: AbortSignal) => {
+    const target = NativeSurfaceLocationSchema.parse(input);
+    const signal = AbortSignal.any([
+      AbortSignal.timeout(5000),
+      ...(cancellation ? [cancellation] : []),
+    ]);
+    const assertCurrent = () => {
+      options.assertOpen();
+      signal.throwIfAborted();
+    };
+    const unavailable = (): never => {
+      throw new Error("Native surface source unavailable");
+    };
+    const observe = async () => {
+      assertCurrent();
+      const proof = await options.run(
+        [
+          "display-message",
+          "-p",
+          "-t",
+          target.runtimePaneId,
+          "#{socket_path}\t#{pid}\t#{session_id}\t#{pane_id}",
+        ],
+        signal,
+      );
+      assertCurrent();
+      if (
+        proof.trimEnd() !==
+        [target.socketPath, target.serverPid, target.sessionId, target.runtimePaneId].join("\t")
+      )
+        unavailable();
+      const snapshot = await options.inventory.discoverTerminalInventory(signal);
+      assertCurrent();
+      if (
+        snapshot.catalog.invalidRuntimeProof ||
+        snapshot.catalog.duplicateSemanticStamp ||
+        snapshot.catalog.duplicateRuntimePaneBinding
+      )
+        unavailable();
+      const matches = snapshot.panes.filter(
+        (pane) =>
+          pane.runtimePaneId === target.runtimePaneId && pane.sessionId === target.sessionId,
+      );
+      if (matches.length !== 1) return unavailable();
+      const pane = { ...matches[0]! };
+      const semantic = TerminalAttachmentSemanticPaneIdSchemaZ.parse(pane.semanticPaneId);
+      const workspace = options.registry.get(pane.workspaceName);
+      if (!workspace || workspace.sessionName !== pane.sessionName) return unavailable();
+      const sessions = (await options.catalog()).filter(
+        (row) => row.sessionName === pane.sessionName,
+      );
+      assertCurrent();
+      if (sessions.length !== 1 || options.registry.get(pane.workspaceName) !== workspace)
+        return unavailable();
+      const live = WorkspaceCatalogLiveSessionIdSchemaZ.parse(sessions[0]!.liveSessionId);
+      return {
+        context: {
+          generation,
+          workspaceName: pane.workspaceName,
+          liveSessionId: live,
+          pane: semantic,
+        },
+        identity: [
+          pane.sessionId,
+          pane.windowId,
+          pane.runtimePaneId,
+          pane.windowStamp ?? null,
+          pane.nativePaneBirthId ?? null,
+        ],
+      };
+    };
+    const before = await observe();
+    const after = await observe();
+    if (JSON.stringify(before) !== JSON.stringify(after)) return unavailable();
+    assertCurrent();
+    return Object.freeze(after.context);
+  };
+}

package/packages/daemon/src/lib/tmux-server-owner.ts

@@ -1,3 +1,5 @@
+import { createNativeSurfaceContextResolver } from "./native-surface-context.ts";
+import type { LocalImageOwner } from "../terminal/graphics/local-image-owner.ts";
 import { shellEscape } from "./shell.ts";
 import {
   createNativeSplitCapabilityProbe,
@@ -68,6 +70,7 @@ import {
 } from "./tmux-server-generation-runner.ts";
 
 export interface NativeTmuxServerOwnerOptions {
+  readonly localImages?: LocalImageOwner;
   readonly environmentId: string;
   readonly serverId: string;
   readonly generation: string;
@@ -485,6 +488,7 @@ export async function createNativeTmuxServerOwner(options: NativeTmuxServerOwner
     }),
   });
   const paneStreamRuntime = createPaneStreamRuntime({
+    localImages: options.localImages,
     daemonInstanceId: generation,
     webSocketUrl: options.webSocketUrl,
     sessionRuntimeRegistry,
@@ -606,6 +610,14 @@ export async function createNativeTmuxServerOwner(options: NativeTmuxServerOwner
     },
     serverId: options.serverId,
     generation,
+    resolveNativeSurfaceContext: createNativeSurfaceContextResolver({
+      generation,
+      assertOpen,
+      registry: workspaceRegistry,
+      catalog,
+      inventory: terminalInventoryRuntime,
+      run: (args, signal) => generationRunAsync(args, signal),
+    }),
     resolvePaneEditorContext,
     catalog,
     readWindowSplitLayout: async (workspaceName: string, input: WindowLinkTarget) => {