@opengeni/runtime 2.5.2 → 2.5.3-canary.1

package/src/sandbox/selfhosted/file-transfer.ts

@@ -0,0 +1,160 @@
+import { blake3 } from "@noble/hashes/blake3";
+import { bytesToHex } from "@noble/hashes/utils";
+import { ControlRequest, ControlResponse, OpState } from "@opengeni/agent-proto";
+import { agentErrorToControlError } from "./control-rpc";
+
+// Below the protocol's 512 KiB chunk maximum, leaving control-envelope headroom.
+export const SELFHOSTED_FILE_CHUNK_BYTES = 256 * 1024;
+
+export function fileContentDigest(content: Uint8Array): string {
+  return bytesToHex(blake3(content));
+}
+
+export class FileTransferOutcomeError extends Error {
+  readonly retryable = false;
+  constructor(
+    readonly operationId: string,
+    readonly phase: "begin" | "upload" | "verify",
+    cause: unknown,
+    readonly observationError?: unknown,
+  ) {
+    const detail = cause instanceof Error ? cause.message : "unknown failure";
+    const observation =
+      observationError instanceof Error ? ` Outcome check: ${observationError.message}` : "";
+    super(
+      `File transfer ${operationId} ${phase} failed: ${detail}.${observation} No mutation was replayed; inspect the destination before another edit.`,
+      { cause },
+    );
+    this.name = "FileTransferOutcomeError";
+  }
+}
+
+/** The caller must reauthorize every request and keep the exact physical route.
+ * No mutation is automatically replayed, including after an ambiguous reply. */
+export async function transferEditorFile(input: {
+  path: string;
+  content: Uint8Array;
+  baseContent?: Uint8Array;
+  request: (requestId: string, op: NonNullable<ControlRequest["op"]>) => Promise<ControlResponse>;
+}): Promise<{ recovered: boolean }> {
+  const opId = `fsw-${crypto.randomUUID()}`;
+  const digest = fileContentDigest(input.content);
+  const checked = (reply: ControlResponse) => {
+    if (reply.error) throw agentErrorToControlError(reply.error, reply.requestId);
+    if (!reply.result) throw new Error("The machine omitted the file-transfer result.");
+    return reply.result;
+  };
+  const send = async (requestId: string, op: NonNullable<ControlRequest["op"]>) => {
+    const reply = await input.request(requestId, op);
+    if (reply.requestId !== requestId)
+      throw new Error("The machine returned a mismatched file-transfer response identity.");
+    return checked(reply);
+  };
+  const isVerified = (observed: NonNullable<ControlResponse["result"]>): boolean =>
+    !(
+      observed.$case !== "opStatus" ||
+      observed.opStatus.opId !== opId ||
+      observed.opStatus.state !== OpState.OP_STATE_COMPLETE ||
+      observed.opStatus.exit?.exitCode !== 0 ||
+      observed.opStatus.exit.cancelled ||
+      observed.opStatus.exit.timedOut ||
+      observed.opStatus.exit.failureCode ||
+      observed.opStatus.exit.digests.content !== digest ||
+      observed.opStatus.exit.totals.content !== String(input.content.byteLength)
+    );
+  const verifyOutcome = async (cancelRunning = false): Promise<void> => {
+    const observed = await send(crypto.randomUUID(), { $case: "opQuery", opQuery: { opId } });
+    if (isVerified(observed)) return;
+    if (
+      cancelRunning &&
+      observed.$case === "opStatus" &&
+      observed.opStatus.opId === opId &&
+      observed.opStatus.state === OpState.OP_STATE_RUNNING
+    ) {
+      // This explicit transfer is being abandoned. Cancel only its known live
+      // identity through the same reauthorized callback; never sweep or expire
+      // other work. A commit racing cancellation must retain its real receipt.
+      const cancelled = await send(crypto.randomUUID(), { $case: "opCancel", opCancel: { opId } });
+      if (isVerified(cancelled)) return;
+      if (
+        cancelled.$case === "opStatus" &&
+        cancelled.opStatus.opId === opId &&
+        cancelled.opStatus.state === OpState.OP_STATE_COMPLETE &&
+        cancelled.opStatus.exit?.cancelled
+      ) {
+        throw new Error("Cancellation of the abandoned transfer's private staging was verified.");
+      }
+    }
+    throw new Error(
+      "The file-transfer outcome is not verified; the operation was not replayed. Inspect the destination before another edit.",
+    );
+  };
+  let phase: "begin" | "upload" | "verify" = "begin";
+  try {
+    const begun = await send(opId, {
+      $case: "opStart",
+      opStart: {
+        op: {
+          $case: "fsWrite",
+          fsWrite: {
+            path: input.path,
+            createParents: true,
+            mode: 0,
+            expectedBaseDigest:
+              input.baseContent === undefined ? "" : fileContentDigest(input.baseContent),
+            expectedAbsent: input.baseContent === undefined,
+            contentDigest: digest,
+            contentSize: String(input.content.byteLength),
+          },
+        },
+        windowBytes: "0",
+        deadlineMs: "0",
+        originId: "",
+      },
+    });
+    if (
+      begun.$case !== "opStart" ||
+      !begun.opStart.accepted ||
+      begun.opStart.status?.opId !== opId
+    ) {
+      throw new Error("The machine did not accept the exact file-transfer operation.");
+    }
+
+    phase = "upload";
+    let offset = 0;
+    let seq = 0;
+    do {
+      const end = Math.min(input.content.byteLength, offset + SELFHOSTED_FILE_CHUNK_BYTES);
+      const reply = await send(crypto.randomUUID(), {
+        $case: "writeChunk",
+        writeChunk: {
+          opId,
+          seq: String(seq),
+          offset: String(offset),
+          bytes: input.content.subarray(offset, end),
+          last: end === input.content.byteLength,
+        },
+      });
+      if (reply.$case !== "writeChunk" || reply.writeChunk.seq !== String(seq)) {
+        throw new Error(
+          "The machine returned a mismatched file-transfer acknowledgment; no chunk was replayed.",
+        );
+      }
+      offset = end;
+      seq += 1;
+    } while (offset < input.content.byteLength);
+    phase = "verify";
+    await verifyOutcome();
+  } catch (error) {
+    if (phase === "verify") throw new FileTransferOutcomeError(opId, phase, error);
+    // An acknowledgment can be lost after commit. Observe this exact operation
+    // once under current authority; never restart it or resend a chunk.
+    try {
+      await verifyOutcome(true);
+      return { recovered: true };
+    } catch (observationError) {
+      throw new FileTransferOutcomeError(opId, phase, error, observationError);
+    }
+  }
+  return { recovered: false };
+}

package/src/sandbox/selfhosted/op-testing.ts

@@ -459,6 +459,7 @@ export class FakeOpRunner implements ControlRpc {
       opId,
       state: complete ? OpState.OP_STATE_COMPLETE : OpState.OP_STATE_RUNNING,
       nextSeq: complete ? (run.exitSeq + 1n).toString() : "1",
+      writeOffset: "0",
       exit: complete ? run.exit : undefined,
       lostReason: OpLostReason.OP_LOST_REASON_UNSPECIFIED,
     };
@@ -617,6 +618,7 @@ function lostStatus(opId: string): OpStatus {
   return {
     opId,
     state: OpState.OP_STATE_LOST,
+    writeOffset: "0",
     nextSeq: "0",
     exit: undefined,
     lostReason: OpLostReason.OP_LOST_REASON_EVICTED,
@@ -627,6 +629,7 @@ function cancelledStatus(opId: string): OpStatus {
   return {
     opId,
     state: OpState.OP_STATE_COMPLETE,
+    writeOffset: "0",
     nextSeq: "1",
     exit: {
       exitCode: -1,

package/src/sandbox/selfhosted/session.ts

@@ -31,6 +31,11 @@ import {
   type StreamChannel,
 } from "@opengeni/agent-proto";
 import { DESKTOP_STREAM_PORT } from "@opengeni/contracts";
+import {
+  SELFHOSTED_FILE_CHUNK_BYTES,
+  fileContentDigest,
+  transferEditorFile,
+} from "./file-transfer";
 // `Manifest` from the ALLOWED sandbox-leaf entrypoint (`@openai/agents/sandbox`
 // re-exports `@openai/agents-core/sandbox`, which exports the Manifest class) —
 // NOT the agent-loop `@openai/agents` root the sandbox leaf forbids. The live
@@ -262,6 +267,7 @@ export interface SelfhostedBackgroundCommandAdoption {
 /** Exact command-admission snapshot. A worker resolves this immediately before
  * every exec/Git admission; retries and already-started operations retain it. */
 export interface SelfhostedOperationAdmission {
+  transactionalFsWriteSupported?: boolean;
   /** Workspace segment of the physical agent/relay route. Personal machines may
    * originate in a different same-organization workspace than the session. */
   workspaceId?: string;
@@ -284,6 +290,8 @@ export interface SelfhostedOperationAdmission {
 }
 
 export interface SelfhostedSessionDeps {
+  /** Exact live daemon capability; absent preserves legacy small-file writes. */
+  transactionalFsWriteSupported?: boolean;
   /** Authorization/session workspace. */
   workspaceId: string;
   /** Physical control-plane workspace. Defaults to workspaceId for legacy and
@@ -488,6 +496,7 @@ export class SelfhostedSession {
   private readonly resourcePolicy: OperationResourcePolicy | undefined;
   private readonly resourcePolicySupported: boolean;
   private readonly operationCpuQuotaSupported: boolean;
+  private readonly transactionalFsWriteSupported: boolean;
   private readonly defaultOpStream: SelfhostedOpStreamDeps | undefined;
   private readonly connectionInstanceId: string;
   private readonly resolveOperationAdmission:
@@ -560,6 +569,7 @@ export class SelfhostedSession {
     this.resourcePolicy = normalizeOperationResourcePolicy(deps.operationResourcePolicy);
     this.resourcePolicySupported = deps.operationResourcePolicySupported === true;
     this.operationCpuQuotaSupported = deps.operationCpuQuotaSupported === true;
+    this.transactionalFsWriteSupported = deps.transactionalFsWriteSupported === true;
     this.defaultOpStream = deps.opStream;
     this.connectionInstanceId = deps.connectionInstanceId;
     this.resolveOperationAdmission = deps.resolveOperationAdmission;
@@ -577,6 +587,7 @@ export class SelfhostedSession {
             subject: this.subject,
             resourcePolicy: this.resourcePolicy,
             opStream: deps.opStream,
+            transactionalFsWriteSupported: this.transactionalFsWriteSupported,
           })
         : undefined;
     // A valid Manifest whose root is the machine's actual effective root. There
@@ -644,6 +655,7 @@ export class SelfhostedSession {
   }
 
   private async admitOperation(commandPolicy: boolean): Promise<{
+    transactionalFsWriteSupported: boolean;
     controlWorkspaceId: string;
     connectionInstanceId: string;
     subject: string;
@@ -664,6 +676,7 @@ export class SelfhostedSession {
         subject: this.subject,
         resourcePolicy: commandPolicy ? this.resourcePolicy : undefined,
         opStream: this.defaultOpStream,
+        transactionalFsWriteSupported: this.transactionalFsWriteSupported,
       };
     }
 
@@ -698,6 +711,7 @@ export class SelfhostedSession {
       ),
       resourcePolicy: commandPolicy ? resourcePolicy : undefined,
       opStream: resolved.opStream,
+      transactionalFsWriteSupported: resolved.transactionalFsWriteSupported === true,
     };
   }
 
@@ -879,7 +893,9 @@ export class SelfhostedSession {
           machineId: this.agentId,
           faultClass: selfhostedFaultClass(error),
           // Known only on a PAYLOAD_TOO_LARGE fault (the agent's encoded_bytes detail).
-          ...(Number.isFinite(encoded) ? { replyBytes: encoded } : {}),
+          ...(Number.isFinite(encoded) && error.detail.direction !== "request"
+            ? { replyBytes: encoded }
+            : {}),
         });
         // Fold the retry count into the DRAINING copy when we actually retried, so
         // the surfaced message reads "…retried N times first…".
@@ -1324,8 +1340,169 @@ export class SelfhostedSession {
     const pathExists = (path: string): Promise<boolean> => this.pathExists(path, runAs);
     const readText = async (path: string): Promise<string> =>
       decoder.decode(await this.readFile({ path, ...(runAs ? { runAs } : {}) }));
-    const writeText = async (path: string, content: string): Promise<void> => {
-      await this.writeFile({ path, content, createParents: true });
+    const writeText = async (
+      path: string,
+      content: string,
+      base?: string | (() => Promise<string | undefined>),
+    ): Promise<((source: string, sourceBase: string) => Promise<void>) | undefined> => {
+      const bytes = encoder.encode(content);
+      if (bytes.byteLength <= SELFHOSTED_FILE_CHUNK_BYTES) {
+        await this.writeFile({ path, content, createParents: true });
+        return;
+      }
+      const initial = await this.admitOperation(false);
+      if (!initial.transactionalFsWriteSupported) {
+        // Older agents may have a larger negotiated message budget. Preserve
+        // their existing writes; a real size rejection remains a typed fault.
+        await this.writeFile({ path, content, createParents: true });
+        return;
+      }
+      if (runAs) {
+        throw new SelfhostedControlError({
+          code: ErrorCode.ERROR_CODE_UNSUPPORTED,
+          message:
+            "Transactional file editing does not support runAs impersonation; no file was written.",
+          reason: null,
+          retryable: false,
+        });
+      }
+      const requestTransfer = async (
+        requestId: string,
+        op: NonNullable<ControlRequest["op"]>,
+      ): Promise<ControlResponse> => {
+        const startedAt = Date.now();
+        try {
+          const current = await this.admitOperation(false);
+          if (
+            !current.transactionalFsWriteSupported ||
+            current.subject !== initial.subject ||
+            current.connectionInstanceId !== initial.connectionInstanceId
+          ) {
+            throw new Error(
+              "The authorized machine connection changed during the file transfer; the operation was not replayed.",
+            );
+          }
+          const response = await this.controlRpc.request(
+            current.subject,
+            {
+              requestId,
+              epoch: this.epoch,
+              op,
+              resourcePolicy: undefined,
+            },
+            { timeoutMs: this.timeoutMs },
+          );
+          if (response.requestId !== requestId)
+            throw new Error("The machine returned a mismatched file-transfer response identity.");
+          const error = response.error
+            ? agentErrorToControlError(response.error, requestId)
+            : undefined;
+          this.emitOp({
+            op: op.$case,
+            outcome: error || !response.result ? "failed" : "ok",
+            healed: false,
+            retries: 0,
+            durationMs: Date.now() - startedAt,
+            machineId: this.agentId,
+            ...(error
+              ? { code: error.code, reason: error.reason, faultClass: selfhostedFaultClass(error) }
+              : {}),
+          });
+          return response;
+        } catch (error) {
+          this.emitOp({
+            op: op.$case,
+            outcome: "failed",
+            healed: false,
+            retries: 0,
+            durationMs: Date.now() - startedAt,
+            machineId: this.agentId,
+            ...(error instanceof SelfhostedControlError
+              ? { code: error.code, reason: error.reason, faultClass: selfhostedFaultClass(error) }
+              : {}),
+          });
+          throw error;
+        }
+      };
+      const resolvedBase = typeof base === "function" ? await base() : base;
+      const transferStartedAt = Date.now();
+      try {
+        const result = await transferEditorFile({
+          path: resolveConnectedMachinePath(this.workspaceRoot, path),
+          content: bytes,
+          ...(resolvedBase === undefined ? {} : { baseContent: encoder.encode(resolvedBase) }),
+          request: requestTransfer,
+        });
+        // Unlike physical request observations, this is a verified file outcome.
+        this.emitOp({
+          op: "fsWrite",
+          outcome: "ok",
+          healed: result.recovered,
+          retries: 0,
+          durationMs: Date.now() - transferStartedAt,
+          machineId: this.agentId,
+        });
+      } catch (error) {
+        this.emitOp({
+          op: "fsWrite",
+          outcome: "failed",
+          healed: false,
+          retries: 0,
+          durationMs: Date.now() - transferStartedAt,
+          machineId: this.agentId,
+        });
+        throw error;
+      }
+      return async (source, sourceBase) => {
+        // A move is verified destination replacement followed by source cleanup,
+        // not an atomic rename. Never retarget cleanup after a runner change.
+        // The source check and deletion are not CAS against unrelated writers.
+        try {
+          const sourcePath = resolveConnectedMachinePath(this.workspaceRoot, source);
+          const sourceBytes: Uint8Array[] = [];
+          let offset = 0;
+          let total = Infinity;
+          while (offset < total) {
+            const reply = await requestTransfer(crypto.randomUUID(), {
+              $case: "fsRead",
+              fsRead: {
+                path: sourcePath,
+                offset: String(offset),
+                length: String(SELFHOSTED_FILE_CHUNK_BYTES),
+              },
+            });
+            if (reply.error) throw agentErrorToControlError(reply.error);
+            if (reply.result?.$case !== "fsRead")
+              throw new Error("Source verification response missing");
+            const part = reply.result.fsRead;
+            total = safeWireSize(part.totalSize, "source file size");
+            if (!part.content.length && offset < total)
+              throw new Error("Source verification was incomplete");
+            sourceBytes.push(part.content);
+            offset += part.content.length;
+          }
+          const actual = new Uint8Array(offset);
+          let cursor = 0;
+          for (const chunk of sourceBytes) {
+            actual.set(chunk, cursor);
+            cursor += chunk.length;
+          }
+          if (fileContentDigest(actual) !== fileContentDigest(encoder.encode(sourceBase)))
+            throw new Error("Source changed before move cleanup");
+          const reply = await requestTransfer(crypto.randomUUID(), {
+            $case: "fsRemove",
+            fsRemove: { path: sourcePath, recursive: false },
+          });
+          if (reply.error) throw agentErrorToControlError(reply.error);
+          if (reply.result?.$case !== "fsRemove")
+            throw new Error("Source cleanup response missing");
+        } catch (cause) {
+          throw new Error(
+            "The destination edit was verified, but source cleanup was not verified. The move was not replayed; inspect both paths.",
+            { cause },
+          );
+        }
+      };
     };
     const deletePath = async (path: string): Promise<void> => {
       const result = await this.call({
@@ -1351,9 +1528,15 @@ export class SelfhostedSession {
         const current = await readText(operation.path);
         const next = applyDiff(current, operation.diff);
         const destination = operation.moveTo ?? operation.path;
-        await writeText(destination, next);
+        const destinationBase =
+          destination === operation.path
+            ? current
+            : async () =>
+                (await pathExists(destination)) ? await readText(destination) : undefined;
+        const cleanup = await writeText(destination, next, destinationBase);
         if (operation.moveTo && destination !== operation.path) {
-          await deletePath(operation.path);
+          if (cleanup) await cleanup(operation.path, current);
+          else await deletePath(operation.path);
         }
         return {};
       },
@@ -1708,6 +1891,7 @@ export class SelfhostedSandboxClient {
   private readonly operationResourcePolicy: SelfhostedOperationResourcePolicy | undefined;
   private readonly operationResourcePolicySupported: boolean | undefined;
   private readonly operationCpuQuotaSupported: boolean | undefined;
+  private readonly transactionalFsWriteSupported: boolean | undefined;
   private readonly resolveOperationAdmission:
     | (() => Promise<SelfhostedOperationAdmission | null>)
     | undefined;
@@ -1748,6 +1932,7 @@ export class SelfhostedSandboxClient {
     operationResourcePolicy?: SelfhostedOperationResourcePolicy;
     operationResourcePolicySupported?: boolean;
     operationCpuQuotaSupported?: boolean;
+    transactionalFsWriteSupported?: boolean;
     resolveOperationAdmission?: () => Promise<SelfhostedOperationAdmission | null>;
     adoptBackgroundCommand?: SelfhostedSessionDeps["adoptBackgroundCommand"];
     settleBackgroundCommand?: SelfhostedSessionDeps["settleBackgroundCommand"];
@@ -1779,6 +1964,7 @@ export class SelfhostedSandboxClient {
     this.operationResourcePolicy = opts.operationResourcePolicy;
     this.operationResourcePolicySupported = opts.operationResourcePolicySupported;
     this.operationCpuQuotaSupported = opts.operationCpuQuotaSupported;
+    this.transactionalFsWriteSupported = opts.transactionalFsWriteSupported;
     this.resolveOperationAdmission = opts.resolveOperationAdmission;
     this.adoptBackgroundCommand = opts.adoptBackgroundCommand;
     this.settleBackgroundCommand = opts.settleBackgroundCommand;
@@ -1822,6 +2008,7 @@ export class SelfhostedSandboxClient {
       ...(this.operationCpuQuotaSupported !== undefined
         ? { operationCpuQuotaSupported: this.operationCpuQuotaSupported }
         : {}),
+      transactionalFsWriteSupported: this.transactionalFsWriteSupported === true,
       ...(this.resolveOperationAdmission !== undefined
         ? { resolveOperationAdmission: this.resolveOperationAdmission }
         : {}),
@@ -1941,6 +2128,7 @@ export interface SelfhostedSessionBuild {
   operationResourcePolicySupported?: boolean;
   /** Exact live CPU enforcement capability paired with the initial snapshot. */
   operationCpuQuotaSupported?: boolean;
+  transactionalFsWriteSupported?: boolean;
   /** Live last-boundary operation admission resolver; see SelfhostedSessionDeps. */
   resolveOperationAdmission?: () => Promise<SelfhostedOperationAdmission | null>;
   adoptBackgroundCommand?: SelfhostedSessionDeps["adoptBackgroundCommand"];
@@ -1996,6 +2184,7 @@ export async function buildSelfhostedBackendSession(
     ...(deps.operationCpuQuotaSupported !== undefined
       ? { operationCpuQuotaSupported: deps.operationCpuQuotaSupported }
       : {}),
+    transactionalFsWriteSupported: deps.transactionalFsWriteSupported === true,
     ...(deps.resolveOperationAdmission !== undefined
       ? { resolveOperationAdmission: deps.resolveOperationAdmission }
       : {}),

package/src/sandbox/workspace-archive.ts

@@ -14,6 +14,8 @@ import {
   type WorkspaceTreeFingerprint,
 } from "@opengeni/contracts";
 import { withSandboxProviderCapture } from "./provider-operation-gate";
+import type { VerifiedHostWorkspaceArchive } from "./archive-spool";
+import { captureHostWorkspaceArchive, fingerprintHostWorkspace } from "./host-archive-spool";
 
 export {
   WORKSPACE_ARCHIVE_DESCRIPTOR_VERSION,
@@ -36,6 +38,55 @@ export type VerifiedWorkspaceArchive = {
   nativeSnapshot?: NativeSnapshotRef;
 };
 
+export type VerifiedWorkspaceArchivePayload =
+  | VerifiedWorkspaceArchive
+  | VerifiedHostWorkspaceArchive;
+
+/** Host-backed portable archives can go directly to object storage without an
+ * intermediate whole-document string or buffer. Existing inline/provider APIs
+ * retain their compatibility path when disk-backed publication is unavailable. */
+export async function captureWorkspaceArchiveForStorage(
+  session: unknown,
+  capturedAtMs: number,
+  options: WorkspaceArchiveCaptureOptions,
+  objectStorageAvailable: boolean,
+): Promise<VerifiedWorkspaceArchivePayload> {
+  const target = session as WorkspaceSession;
+  const root = hostBackedWorkspaceRoot(target);
+  if (
+    process.platform !== "linux" ||
+    !root ||
+    !objectStorageAvailable ||
+    options.strategy === "portable_tar"
+  ) {
+    return await captureVerifiedWorkspaceArchive(session, capturedAtMs, options);
+  }
+  return await withSandboxProviderCapture(session, async () => {
+    const { spool, workspace } = await captureHostWorkspaceArchive(
+      root,
+      workspaceFingerprintExcludes(target),
+    );
+    return {
+      kind: "host_spool" as const,
+      spool,
+      descriptor: {
+        version: 1 as const,
+        revision: `wa1:${String(capturedAtMs).padStart(13, "0")}:${spool.sha256}`,
+        archiveSha256: spool.sha256,
+        archiveBytes: spool.byteSize,
+        capturedAt: new Date(capturedAtMs).toISOString(),
+        workspace,
+      },
+    };
+  });
+}
+
+export async function disposeWorkspaceArchive(
+  archive: VerifiedWorkspaceArchivePayload | undefined,
+): Promise<void> {
+  if (archive?.kind === "host_spool") await archive.spool.dispose();
+}
+
 export type WorkspaceArchiveIntegrityCode =
   | "archive_metadata_missing"
   | "archive_metadata_invalid"
@@ -789,7 +840,9 @@ export async function verifyRestoredWorkspace(
               "selected host-backed workspace archive was restored by a non-host-backed provider",
             );
           }
-          return fingerprintHostBackedWorkspace(root, workspaceFingerprintExcludes(target));
+          return process.platform === "linux"
+            ? fingerprintHostWorkspace(root, workspaceFingerprintExcludes(target))
+            : fingerprintHostBackedWorkspace(root, workspaceFingerprintExcludes(target));
         })()
       : await fingerprintRemoteWorkspace(target);
   if (!fingerprintsEqual(actual, descriptor.workspace)) {