test(onboard): centralize sandbox identity fixtures

ci/test-file-size-budget.json

@@ -8,7 +8,7 @@
     "test/generation/generate-openclaw-config.test.ts": 1898,
     "test/installer-integration/install-preflight.test.ts": 3025,
     "test/agents/openclaw/runtime/nemoclaw-start.test.ts": 4626,
-    "test/onboarding/onboard-messaging.test.ts": 1979,
+    "test/onboarding/onboard-messaging.test.ts": 1976,
     "test/onboarding/onboard-selection.test.ts": 4176
   }
 }

src/lib/onboard/__test-helpers__/sandbox-gpu-create-flow.ts

@@ -50,13 +50,13 @@ export function createGpuFlowInput(): SandboxGpuCreateFlowInput {
   };
 }
 
-export function createGpuFlowDeps(): SandboxGpuCreateFlowDeps {
+export function createGpuFlowDeps(sandboxId = "alpha-sandbox-id"): SandboxGpuCreateFlowDeps {
   return {
     runOpenshell: vi.fn((args: string[]) =>
       args[0] === "sandbox" && args[1] === "get"
         ? {
             status: 0,
-            stdout: "Name: alpha\nId: alpha-sandbox-id\nState: Ready\n",
+            stdout: `Name: alpha\nId: ${sandboxId}\nState: Ready\n`,
             stderr: "",
           }
         : { status: 0, stdout: "", stderr: "" },

src/lib/onboard/sandbox-gpu-create-flow.test.ts

@@ -350,12 +350,13 @@ describe("runSandboxGpuCreateFlow provider-owned managed create", () => {
       intendedWorkloadArgv: launch.intendedSandboxStartupCommand,
       expectedSupervisorArgv: ["/mxc/supervisor"],
     };
-    const deps = createDeps();
+    const sandboxId = "mxc-alpha";
+    const deps = createDeps(sandboxId);
     const adapterOverride = {} as never;
     deps.createManagedBootstrapAdapter = vi.fn(() => adapterOverride);
-    deps.runOpenshell = vi.fn(() => readySandboxGetResult("alpha-sandbox-id"));
+    deps.runOpenshell = vi.fn(() => readySandboxGetResult(sandboxId));
     vi.mocked(deps.runCaptureOpenshell).mockImplementation((args) =>
-      args[1] === "get" ? "ID: alpha-sandbox-id\n" : "alpha Ready",
+      args[1] === "get" ? `ID: ${sandboxId}\n` : "alpha Ready",
     );
     recoverUnfinished.mockRejectedValueOnce(new Error("unfinished recovery failed"));
 
@@ -426,7 +427,7 @@ describe("runSandboxGpuCreateFlow provider-owned managed create", () => {
     expect(mocks.streamSandboxCreate).not.toHaveBeenCalled();
     expect(errorOutput()).toContain("recovery stopped before sandbox 'alpha' was created");
     expect(errorOutput()).toContain("Transaction");
-    expect(errorOutput()).toContain("durable sandbox ID mxc-alpha");
+    expect(errorOutput()).toContain(`durable sandbox ID ${sandboxId}`);
     expect(errorOutput()).toContain("OpenShell's sandbox get command");
     expect(errorOutput()).toContain("never delete a runtime by mutable sandbox name");
     expect(errorOutput()).toContain("Authorization: Bearer <REDACTED>");

test/helpers/managed-image-buildless-e2e.ts

@@ -149,7 +149,6 @@ const managedBootstrapCalls = [];
 const registerCalls = [];
 const runnerCommands = [];
 const spawnCalls = [];
-let sandboxCreated = recreate;
 let existingEntryAvailable = recreate;
 let registeredSandbox = null;
 let managedHermesVolume = recreate ? {
@@ -193,6 +192,11 @@ const replace = (target, name, value) => {
 const childProcess = require("node:child_process");
 const fixtureMocks = require(${source("test/helpers/onboard-script-mocks.cjs")});
 fixtureMocks.mockStandaloneGatewayTeardownAuthority();
+const createdSandbox = fixtureMocks.createCreatedSandboxFixture({
+  sandboxName,
+  sandboxId: "fixture-managed-sandbox",
+  lifecycleState: recreate ? "created" : "absent",
+});
 
 const coreVersion = require(${source("src/lib/core/version.ts")});
 replace(coreVersion, "getVersion", () => catalogRelease);
@@ -420,16 +424,16 @@ runner.run = (command, options = {}) => {
   const argv = Array.isArray(command) ? command.map(String) : [];
   const normalized = normalize(command);
   runnerCommands.push(normalized);
-  sandboxCreated = normalized.includes("sandbox delete") ? false : sandboxCreated;
-  existingEntryAvailable = normalized.includes("sandbox delete") ? false : existingEntryAvailable;
+  if (
+    normalized.includes("sandbox delete") &&
+    createdSandbox.state.lifecycleState === "created"
+  ) {
+    createdSandbox.delete();
+    existingEntryAvailable = false;
+  }
   if (/(?:^|\s)docker(?:\s+buildx)?\s+build(?:\s|$)/u.test(normalized)) {
     return poison("docker build");
   }
-  if (normalized.includes("sandbox get") && normalized.includes(sandboxName)) {
-    return sandboxCreated
-      ? { status: 0, stdout: "Name: " + sandboxName + "\nId: fixture-managed-sandbox\n", stderr: "" }
-      : { status: 1, stdout: "", stderr: "sandbox not found" };
-  }
   if (argv[0] === "docker" && argv[1] === "volume") {
     const volumeName = argv.at(-1);
     if (argv[2] === "inspect") {
@@ -449,16 +453,13 @@ runner.run = (command, options = {}) => {
       return { status: 0, stdout: volumeName + "\n", stderr: "" };
     }
   }
-  return { status: 0, stdout: "", stderr: "" };
+  return createdSandbox.run(command) ?? { status: 0, stdout: "", stderr: "" };
 };
 runner.runFile = (file, args = []) => runner.run([file, ...args]);
 runner.runCapture = (command) => {
   const normalized = normalize(command);
   runnerCommands.push(normalized);
-  const createdIdentity = fixtureMocks.mockCreatedSandboxIdentityList(command, {
-    sandboxName,
-    sandboxId: "fixture-managed-sandbox",
-  });
+  const createdIdentity = createdSandbox.capture(command);
   if (createdIdentity !== null) return createdIdentity;
   if (normalized.includes("policy get") && normalized.includes("--output json")) {
     return JSON.stringify({
@@ -474,12 +475,6 @@ runner.runCapture = (command) => {
   if (normalized.includes("gateway info")) {
     return "Gateway endpoint: http://127.0.0.1:8080";
   }
-  if (normalized.includes("sandbox get") && normalized.includes(sandboxName)) {
-    return sandboxCreated
-      ? "Name: " + sandboxName + "\nId: fixture-managed-sandbox\nState: Ready"
-      : "";
-  }
-  if (normalized.includes("sandbox list")) return sandboxName + " Ready";
   if (normalized.includes("forward list")) {
     return sandboxName + " 127.0.0.1 18789 23189 running";
   }
@@ -543,7 +538,7 @@ const sourceEntry = recreate ? fixtureMocks.managedSandboxPolicyReceiptFixture({
     credentialProxyReplayRequired: true,
     shared: true,
   },
-}, { sandboxName, sandboxId: "fixture-managed-sandbox" }) : null;
+}, { sandboxName, sandboxId: createdSandbox.state.sandboxId }) : null;
 registry.getSandbox = () => registeredSandbox ?? (existingEntryAvailable ? sourceEntry : null);
 registry.getDefault = () => null;
 registry.listExtraProviders = () => [];
@@ -578,7 +573,13 @@ childProcess.spawn = (command, args = [], options = {}) => {
   if (/(?:^|\s)docker(?:\s+buildx)?\s+build(?:\s|$)/u.test(normalized)) {
     return poison("docker build");
   }
-  if (normalized.includes("sandbox create")) sandboxCreated = true;
+  if (normalized.includes("sandbox create")) {
+    if (createdSandbox.state.lifecycleState === "deleted") {
+      createdSandbox.recreate([command, ...argv]);
+    } else {
+      createdSandbox.create([command, ...argv]);
+    }
+  }
   spawnCalls.push({ command: String(command), args: argv });
   const child = new EventEmitter();
   child.stdout = new EventEmitter();

test/helpers/onboard-created-sandbox-fixture.test.ts

@@ -0,0 +1,188 @@
+// SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import { describe, expect, it } from "vitest";
+import { createRequire } from "node:module";
+
+import {
+  NEMOCLAW_CREATE_ATTEMPT_LABEL,
+  NEMOCLAW_CREATE_ATTEMPT_NONCE_HEX_LENGTH,
+  isOpenShellSandboxId,
+  parseOpenShellSandboxId,
+  parseStrictOpenShellSandboxListJson,
+} from "../../src/lib/adapters/openshell/sandbox-identity";
+
+type CreatedSandboxFixture = {
+  readonly capture: (command: string[]) => string | null;
+  readonly create: (command: string[]) => void;
+  readonly delete: () => void;
+  readonly recreate: (command: string[]) => void;
+  readonly setPhase: (phase: string) => void;
+  readonly run: (command: string[]) => { status: number; stdout: Buffer; stderr: Buffer } | null;
+  readonly state: Readonly<{
+    sandboxName: string;
+    sandboxId: string;
+    gatewayName: string;
+    phase: string;
+    lifecycleState: string;
+    generation: number;
+    createAttemptNonce: string | null;
+    ownerScopedIdentityObserved: boolean;
+  }>;
+};
+
+const requireCjs = createRequire(import.meta.url);
+const { createCreatedSandboxFixture } = requireCjs("./onboard-script-mocks.cjs") as {
+  createCreatedSandboxFixture: (options?: Record<string, unknown>) => CreatedSandboxFixture;
+};
+
+const CREATE_ATTEMPT_NONCE = "a".repeat(NEMOCLAW_CREATE_ATTEMPT_NONCE_HEX_LENGTH);
+
+function selectorListCommand(gatewayName: string | null, nonce = CREATE_ATTEMPT_NONCE): string[] {
+  return [
+    "openshell",
+    "sandbox",
+    "list",
+    ...(gatewayName === null ? [] : ["-g", gatewayName]),
+    "--selector",
+    `${NEMOCLAW_CREATE_ATTEMPT_LABEL}=${nonce}`,
+    "--output",
+    "json",
+    "--limit",
+    "2",
+  ];
+}
+
+function createCommand(nonce = CREATE_ATTEMPT_NONCE): string[] {
+  return ["openshell", "sandbox", "create", "--label", `${NEMOCLAW_CREATE_ATTEMPT_LABEL}=${nonce}`];
+}
+
+describe("created sandbox fixture", () => {
+  it("uses one ID for create, list, and get observations (#10463)", () => {
+    const fixture = createCreatedSandboxFixture({
+      sandboxName: "alpha",
+      sandboxId: "sandbox-alpha",
+      gatewayName: "gateway-alpha",
+    });
+
+    expect(fixture.capture(selectorListCommand("gateway-alpha"))).toBe("[]");
+    fixture.create(createCommand());
+    const createdSandboxId = fixture.state.sandboxId;
+
+    const selectorOutput = fixture.capture(selectorListCommand("gateway-alpha"));
+    const rows = parseStrictOpenShellSandboxListJson(selectorOutput ?? "");
+    expect(rows).toHaveLength(1);
+    expect(rows?.[0]?.id).toBe(createdSandboxId);
+
+    const listOutput = fixture.capture(["openshell", "sandbox", "list", "-g", "gateway-alpha"]);
+    expect(listOutput).toBe("alpha Ready\n");
+    expect(fixture.state.sandboxId).toBe(createdSandboxId);
+    expect(fixture.run(["openshell", "sandbox", "get", "alpha"])).toBeNull();
+
+    const getOutput = fixture.capture([
+      "openshell",
+      "sandbox",
+      "get",
+      "-g",
+      "gateway-alpha",
+      "alpha",
+    ]);
+    expect(parseOpenShellSandboxId(getOutput ?? "")).toBe(createdSandboxId);
+    expect(
+      parseOpenShellSandboxId(
+        fixture.run(["openshell", "sandbox", "get", "alpha"])?.stdout.toString() ?? "",
+      ),
+    ).toBe(createdSandboxId);
+  });
+
+  it("invalidates the prior ID before recreation publishes a new ID (#10463)", () => {
+    const fixture = createCreatedSandboxFixture({
+      sandboxName: "alpha",
+      sandboxId: "sandbox-alpha",
+      gatewayName: "gateway-alpha",
+    });
+    fixture.create(createCommand());
+    const priorSandboxId = fixture.state.sandboxId;
+
+    fixture.delete();
+    expect(fixture.capture(selectorListCommand("gateway-alpha"))).toBe("[]");
+    expect(fixture.capture(["openshell", "sandbox", "get", "-g", "gateway-alpha", "alpha"])).toBe(
+      "",
+    );
+    expect(
+      fixture.run(["openshell", "sandbox", "get", "-g", "gateway-alpha", "alpha"]),
+    ).toMatchObject({ status: 1 });
+
+    const replacementNonce = "b".repeat(NEMOCLAW_CREATE_ATTEMPT_NONCE_HEX_LENGTH);
+    fixture.recreate(createCommand(replacementNonce));
+    const replacementSandboxId = fixture.state.sandboxId;
+    expect(replacementSandboxId).not.toBe(priorSandboxId);
+    const replacementRows = parseStrictOpenShellSandboxListJson(
+      fixture.capture(selectorListCommand("gateway-alpha", replacementNonce)) ?? "",
+    );
+    expect(fixture.capture(selectorListCommand("gateway-alpha"))).toBe("[]");
+    expect(replacementRows?.[0]?.id).toBe(replacementSandboxId);
+    expect(replacementRows?.[0]?.id).not.toBe(priorSandboxId);
+    expect(
+      parseOpenShellSandboxId(
+        fixture.capture(["openshell", "sandbox", "get", "-g", "gateway-alpha", "alpha"]) ?? "",
+      ),
+    ).toBe(replacementSandboxId);
+  });
+
+  it("keeps a replacement ID valid for a maximum-length input (#10463)", () => {
+    const maximumSandboxId = "a".repeat(512);
+    const fixture = createCreatedSandboxFixture({ sandboxId: maximumSandboxId });
+    fixture.create(createCommand());
+    fixture.delete();
+    fixture.recreate(createCommand("b".repeat(NEMOCLAW_CREATE_ATTEMPT_NONCE_HEX_LENGTH)));
+
+    expect(fixture.state.sandboxId).not.toBe(maximumSandboxId);
+    expect(isOpenShellSandboxId(fixture.state.sandboxId)).toBe(true);
+  });
+
+  it.each([
+    ["a missing", undefined],
+    ["an empty", ""],
+    ["a malformed", "invalid/id"],
+  ])("rejects %s durable sandbox ID (#10463)", (_case, sandboxId) => {
+    expect(() => createCreatedSandboxFixture({ sandboxId })).toThrow(
+      "Created sandbox fixture requires one durable sandbox ID.",
+    );
+  });
+
+  it("does not answer an identity observation for another gateway (#10463)", () => {
+    const fixture = createCreatedSandboxFixture({
+      sandboxName: "alpha",
+      sandboxId: "sandbox-alpha",
+      gatewayName: "gateway-alpha",
+    });
+    fixture.create(createCommand());
+
+    expect(fixture.capture(selectorListCommand("gateway-bravo"))).toBeNull();
+    expect(
+      fixture.capture(["openshell", "sandbox", "get", "-g", "gateway-bravo", "alpha"]),
+    ).toBeNull();
+    expect(fixture.capture(selectorListCommand(null))).toBeNull();
+    expect(fixture.capture(["openshell", "sandbox", "get", "alpha"])).toBeNull();
+  });
+
+  it("does not answer a selector for another create attempt (#10463)", () => {
+    const fixture = createCreatedSandboxFixture({ gatewayName: "gateway-alpha" });
+    fixture.create(createCommand());
+
+    expect(
+      fixture.capture(
+        selectorListCommand("gateway-alpha", "b".repeat(NEMOCLAW_CREATE_ATTEMPT_NONCE_HEX_LENGTH)),
+      ),
+    ).toBe("[]");
+  });
+
+  it("rejects a malformed create-attempt nonce (#10463)", () => {
+    const fixture = createCreatedSandboxFixture();
+
+    expect(() => fixture.create(createCommand("invalid"))).toThrow(
+      "Created sandbox fixture requires one valid create-attempt label.",
+    );
+  });
+});

test/helpers/onboard-openshell-fixture.ts

@@ -8,13 +8,17 @@ function writeExecutable(target: string, contents: string): void {
   fs.writeFileSync(target, contents, { mode: 0o755 });
 }
 
+export const ONBOARD_READY_SANDBOX_ID = "sbx-4f2a91c0d7";
+
 export function writeOkOpenshell(
   fakeBin: string,
   options: { gatewayPort?: number; readySandboxGet?: boolean } = {},
 ): void {
   const gatewayPort = options.gatewayPort ?? 8080;
   const sandboxGet = options.readySandboxGet
-    ? 'if [ "${1:-}" = sandbox ] && [ "${2:-}" = get ]; then printf "Sandbox:\\n\\n  Id: sbx-4f2a91c0d7\\n  Name: %s\\n  Phase: Ready\\n" "${!#}"; fi\n'
+    ? 'if [ "${1:-}" = sandbox ] && [ "${2:-}" = get ]; then printf "Sandbox:\\n\\n  Id: ' +
+      ONBOARD_READY_SANDBOX_ID +
+      '\\n  Name: %s\\n  Phase: Ready\\n" "${!#}"; fi\n'
     : "";
   writeExecutable(
     path.join(fakeBin, "openshell"),