diff --git a/package-lock.json b/package-lock.json
index f49d70ecec19..93fce5f51916 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -23947,6 +23947,9 @@
             "name": "@babylonjs/inspector",
             "version": "9.1.0",
             "license": "Apache-2.0",
+            "bin": {
+                "babylon-inspector": "bin/inspector-cli.mjs"
+            },
             "devDependencies": {
                 "@dev/build-tools": "^1.0.0",
                 "@dev/inspector": "1.0.0",
@@ -23954,9 +23957,11 @@
                 "@rollup/plugin-commonjs": "^26.0.1",
                 "@rollup/plugin-node-resolve": "^15.2.3",
                 "@rollup/plugin-typescript": "^11.1.6",
+                "@types/ws": "^8.5.0",
                 "chalk": "^5.3.0",
                 "rollup": "^4.59.0",
-                "rollup-plugin-dts": "^6.1.1"
+                "rollup-plugin-dts": "^6.1.1",
+                "ws": "^8.18.0"
             },
             "peerDependencies": {
                 "@babylonjs/addons": "^9.0.0",
@@ -23974,6 +23979,28 @@
                 "usehooks-ts": "^3.1.1"
             }
         },
+        "packages/public/@babylonjs/inspector-v2/node_modules/ws": {
+            "version": "8.20.0",
+            "resolved": "https://registry.npmjs.org/ws/-/ws-8.20.0.tgz",
+            "integrity": "sha512-sAt8BhgNbzCtgGbt2OxmpuryO63ZoDk/sqaB/znQm94T4fCEsy/yV+7CdC1kJhOU9lboAEU7R3kquuycDoibVA==",
+            "dev": true,
+            "license": "MIT",
+            "engines": {
+                "node": ">=10.0.0"
+            },
+            "peerDependencies": {
+                "bufferutil": "^4.0.1",
+                "utf-8-validate": ">=5.0.2"
+            },
+            "peerDependenciesMeta": {
+                "bufferutil": {
+                    "optional": true
+                },
+                "utf-8-validate": {
+                    "optional": true
+                }
+            }
+        },
         "packages/public/@babylonjs/ktx2decoder": {
             "version": "9.1.0",
             "license": "Apache-2.0",
diff --git a/packages/dev/core/src/Meshes/mesh.ts b/packages/dev/core/src/Meshes/mesh.ts
index 92764e749288..f6ef5e2d91ba 100644
--- a/packages/dev/core/src/Meshes/mesh.ts
+++ b/packages/dev/core/src/Meshes/mesh.ts
@@ -4188,7 +4188,7 @@ export class Mesh extends AbstractMesh implements IGetSetVerticesData {
         // Physics
         //TODO implement correct serialization for physics impostors.
         if (this.getScene()._getComponent(SceneComponentConstants.NAME_PHYSICSENGINE)) {
-            const impostor = this.getPhysicsImpostor();
+            const impostor = this.getPhysicsImpostor?.();
             if (impostor) {
                 serializationObject.physicsMass = impostor.getParam("mass");
                 serializationObject.physicsFriction = impostor.getParam("friction");
@@ -4234,7 +4234,7 @@ export class Mesh extends AbstractMesh implements IGetSetVerticesData {
             // Physics
             //TODO implement correct serialization for physics impostors.
             if (this.getScene()._getComponent(SceneComponentConstants.NAME_PHYSICSENGINE)) {
-                const impostor = instance.getPhysicsImpostor();
+                const impostor = instance.getPhysicsImpostor?.();
                 if (impostor) {
                     serializationInstance.physicsMass = impostor.getParam("mass");
                     serializationInstance.physicsFriction = impostor.getParam("friction");
diff --git a/packages/dev/inspector-v2/package.json b/packages/dev/inspector-v2/package.json
index d7108a5aaa46..b342935fc90a 100644
--- a/packages/dev/inspector-v2/package.json
+++ b/packages/dev/inspector-v2/package.json
@@ -14,7 +14,8 @@
         "serve": "webpack serve --mode development",
         "watch": "tsc -b tsconfig.build.json -w",
         "watch:dev": "npm run watch",
-        "makeAvatar": "node scripts/makeAvatar.mjs"
+        "makeAvatar": "node scripts/makeAvatar.mjs",
+        "babylon-inspector": "node --no-warnings dist/cli/cli.js --bridge-script dist/cli/bridge.js"
     },
     "devDependencies": {
         "@dev/addons": "1.0.0",
diff --git a/packages/dev/inspector-v2/src/cli/bridge.ts b/packages/dev/inspector-v2/src/cli/bridge.ts
new file mode 100644
index 000000000000..477f2e8a1c51
--- /dev/null
+++ b/packages/dev/inspector-v2/src/cli/bridge.ts
@@ -0,0 +1,258 @@
+/* eslint-disable no-console */
+import { fileURLToPath } from "url";
+import { type WebSocket, WebSocketServer } from "./webSocket.js";
+import { LoadConfig } from "./config.js";
+import { type BrowserRequest, type BrowserResponse, type CliRequest, type CliResponse, type SessionInfo } from "./protocol.js";
+
+interface ISession extends SessionInfo {
+    /** The WebSocket connection for this session. */
+    ws: WebSocket;
+}
+
+/**
+ * Configuration for starting the bridge.
+ */
+export interface IBridgeConfig {
+    /** WebSocket port for browser sessions. Use 0 for OS-assigned port. */
+    browserPort: number;
+    /** WebSocket port for CLI connections. Use 0 for OS-assigned port. */
+    cliPort: number;
+    /** Timeout in ms for waiting for an initial session on a sessions request. Defaults to 5000. */
+    sessionWaitTimeoutMs?: number;
+}
+
+/**
+ * Handle returned by {@link startBridge} to control and inspect the running bridge.
+ */
+export interface IBridgeHandle {
+    /** The actual port the browser WebSocket server is listening on. */
+    browserPort: number;
+    /** The actual port the CLI WebSocket server is listening on. */
+    cliPort: number;
+    /** Shuts down the bridge, closing all connections and servers. */
+    shutdown: () => void;
+}
+
+/**
+ * Starts the Inspector bridge with the given configuration.
+ * @param config The ports to listen on. Use port 0 for OS-assigned ports.
+ * @returns A promise that resolves with a handle to control the running bridge.
+ */
+export async function StartBridge(config: IBridgeConfig): Promise<IBridgeHandle> {
+    let nextSessionId = 1;
+    const sessions = new Map<number, ISession>();
+    const pendingBrowserRequests = new Map<string, (response: string) => void>();
+    const sessionAddedListeners: (() => void)[] = [];
+    let requestCounter = 0;
+
+    function generateRequestId(): string {
+        return `bridge-req-${++requestCounter}`;
+    }
+
+    const sessionWaitTimeout = config.sessionWaitTimeoutMs ?? 5000;
+
+    async function waitForSession(): Promise<void> {
+        if (sessions.size > 0) {
+            return;
+        }
+        return await new Promise<void>((resolve) => {
+            const timer = setTimeout(() => {
+                const index = sessionAddedListeners.indexOf(listener);
+                if (index !== -1) {
+                    sessionAddedListeners.splice(index, 1);
+                }
+                resolve();
+            }, sessionWaitTimeout);
+
+            const listener = () => {
+                clearTimeout(timer);
+                const index = sessionAddedListeners.indexOf(listener);
+                if (index !== -1) {
+                    sessionAddedListeners.splice(index, 1);
+                }
+                resolve();
+            };
+            sessionAddedListeners.push(listener);
+        });
+    }
+
+    async function waitForBrowserResponse(requestId: string, timeoutMs = 30000): Promise<string> {
+        return await new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                pendingBrowserRequests.delete(requestId);
+                reject(new Error("Timeout"));
+            }, timeoutMs);
+
+            pendingBrowserRequests.set(requestId, (response) => {
+                clearTimeout(timer);
+                resolve(response);
+            });
+        });
+    }
+
+    // Browser-facing WebSocket server.
+    const browserWss = new WebSocketServer({ host: "127.0.0.1", port: config.browserPort });
+
+    // CLI-facing WebSocket server.
+    const cliWss = new WebSocketServer({ host: "127.0.0.1", port: config.cliPort });
+
+    browserWss.on("connection", (socket) => {
+        let session: ISession | null = null;
+
+        socket.on("message", (data) => {
+            let message: BrowserRequest;
+            try {
+                message = JSON.parse(data.toString());
+            } catch {
+                return;
+            }
+
+            switch (message.type) {
+                case "register": {
+                    const id = nextSessionId++;
+                    session = {
+                        id,
+                        name: message.name,
+                        connectedAt: new Date().toISOString(),
+                        ws: socket,
+                    };
+                    sessions.set(id, session);
+                    console.log(`Session ${id} registered: "${session.name}"`);
+                    for (const listener of sessionAddedListeners.splice(0)) {
+                        listener();
+                    }
+                    break;
+                }
+                case "commandListResponse":
+                case "commandResponse": {
+                    // Forward response back to the CLI that requested it.
+                    const resolve = pendingBrowserRequests.get(message.requestId);
+                    if (resolve) {
+                        pendingBrowserRequests.delete(message.requestId);
+                        resolve(JSON.stringify(message));
+                    }
+                    break;
+                }
+            }
+        });
+
+        socket.on("close", () => {
+            if (session) {
+                console.log(`Session ${session.id} disconnected: "${session.name}"`);
+                sessions.delete(session.id);
+            }
+        });
+    });
+
+    cliWss.on("connection", (socket) => {
+        socket.on("message", async (data) => {
+            let message: CliRequest;
+            try {
+                message = JSON.parse(data.toString());
+            } catch {
+                return;
+            }
+
+            function sendCliResponse(response: CliResponse) {
+                socket.send(JSON.stringify(response));
+            }
+
+            function sendBrowserRequest(target: ISession, request: BrowserResponse) {
+                target.ws.send(JSON.stringify(request));
+            }
+
+            switch (message.type) {
+                case "sessions": {
+                    // Wait for at least one session to connect before responding.
+                    await waitForSession();
+                    const sessionList: SessionInfo[] = Array.from(sessions.values()).map((s) => ({
+                        id: s.id,
+                        name: s.name,
+                        connectedAt: s.connectedAt,
+                    }));
+                    sendCliResponse({ type: "sessionsResponse", sessions: sessionList });
+                    break;
+                }
+                case "commands": {
+                    const session = sessions.get(message.sessionId);
+                    if (!session) {
+                        sendCliResponse({ type: "commandsResponse", error: `No session with id ${message.sessionId}` });
+                        break;
+                    }
+                    const requestId = generateRequestId();
+                    sendBrowserRequest(session, { type: "listCommands", requestId });
+                    try {
+                        const response = await waitForBrowserResponse(requestId);
+                        socket.send(response);
+                    } catch {
+                        sendCliResponse({ type: "commandsResponse", error: "Timeout waiting for browser response" });
+                    }
+                    break;
+                }
+                case "exec": {
+                    const session = sessions.get(message.sessionId);
+                    if (!session) {
+                        sendCliResponse({ type: "execResponse", error: `No session with id ${message.sessionId}` });
+                        break;
+                    }
+                    const requestId = generateRequestId();
+                    sendBrowserRequest(session, {
+                        type: "execCommand",
+                        requestId,
+                        commandId: message.commandId,
+                        args: message.args,
+                    });
+                    try {
+                        const response = await waitForBrowserResponse(requestId);
+                        socket.send(response);
+                    } catch {
+                        sendCliResponse({ type: "execResponse", error: "Timeout waiting for browser response" });
+                    }
+                    break;
+                }
+                case "stop": {
+                    sendCliResponse({ type: "stopResponse", success: true });
+                    shutdown();
+                    break;
+                }
+            }
+        });
+    });
+
+    function shutdown(): void {
+        console.log("Inspector bridge shutting down.");
+
+        for (const session of sessions.values()) {
+            session.ws.close();
+        }
+        sessions.clear();
+
+        browserWss.close();
+        cliWss.close();
+    }
+
+    // Wait for both servers to be listening before returning.
+    await Promise.all([new Promise<void>((resolve) => browserWss.on("listening", resolve)), new Promise<void>((resolve) => cliWss.on("listening", resolve))]);
+
+    const actualBrowserPort = (browserWss.address() as import("net").AddressInfo).port;
+    const actualCliPort = (cliWss.address() as import("net").AddressInfo).port;
+
+    console.log(`Inspector bridge started.`);
+    console.log(`  Browser port: ${actualBrowserPort}`);
+    console.log(`  CLI port:     ${actualCliPort}`);
+
+    return {
+        browserPort: actualBrowserPort,
+        cliPort: actualCliPort,
+        shutdown,
+    };
+}
+
+// Auto-start when run directly (not when imported for testing).
+if (process.argv[1] === fileURLToPath(import.meta.url)) {
+    void (async () => {
+        const handle = await StartBridge(LoadConfig());
+        process.on("SIGTERM", () => handle.shutdown());
+        process.on("SIGINT", () => handle.shutdown());
+    })();
+}
diff --git a/packages/dev/inspector-v2/src/cli/cli.ts b/packages/dev/inspector-v2/src/cli/cli.ts
new file mode 100644
index 000000000000..804b6f5e6ab1
--- /dev/null
+++ b/packages/dev/inspector-v2/src/cli/cli.ts
@@ -0,0 +1,462 @@
+/* eslint-disable no-console */
+import { spawn } from "child_process";
+import { dirname, join, resolve } from "path";
+import { fileURLToPath } from "url";
+import { parseArgs } from "util";
+import { WebSocket } from "./webSocket.js";
+import { LoadConfig } from "./config.js";
+import {
+    type CliRequest,
+    type CliResponse,
+    type CommandArgInfo,
+    type CommandInfo,
+    type CommandsResponse,
+    type ExecResponse,
+    type SessionInfo,
+    type SessionsResponse,
+} from "./protocol.js";
+
+const Config = LoadConfig();
+
+const HELP_TEXT = `babylon-inspector — Interact with running Babylon.js scenes from the terminal.
+
+USAGE
+  babylon-inspector [options]
+  babylon-inspector --command <command-id> [--arg value ...]
+
+OPTIONS
+  --help                   Show this help message.
+  --session [session-id]   List active sessions, or specifies the target session.
+                           A session id is only needed when multiple sessions
+                           are active.
+  --command [command-id]   List available commands, or execute one.
+                           Use --command <id> --help to see its arguments.
+  --stop                   Stop the bridge process.
+
+CONFIGURATION
+  Place a .babyloninspector JSON file anywhere in the directory parent chain:
+    { "browserPort": 4400, "cliPort": 4401 }
+
+EXAMPLES
+  babylon-inspector --session
+  babylon-inspector --command
+  babylon-inspector --session 2 --command
+  babylon-inspector --command query-mesh --help
+  babylon-inspector --command query-mesh --uniqueId 42
+  babylon-inspector --session 2 --command query-mesh --uniqueId 42
+`;
+
+const KnownOptions = new Set(["help", "stop", "session", "command", "bridge-script"]);
+
+/**
+ * Parsed CLI arguments for the Inspector CLI.
+ */
+export interface IParsedArgs {
+    /** Whether the user requested help. */
+    help: boolean;
+    /** Whether --session was specified. */
+    session: boolean;
+    /** The session id value, if provided. */
+    sessionId?: string;
+    /** Whether the user requested the bridge to stop. */
+    stop: boolean;
+    /** Whether --command was specified. */
+    command: boolean;
+    /** Optional path to the bridge script. */
+    bridgeScript?: string;
+    /** Remaining positional and unknown arguments (command id + command args). */
+    rest: string[];
+}
+
+/**
+ * Parses the CLI arguments into a structured object.
+ * @param argv Optional array of arguments to parse. Defaults to process.argv.
+ * @returns The parsed arguments.
+ */
+export function ParseCliArgs(argv?: string[]): IParsedArgs {
+    const { values, tokens } = parseArgs({
+        options: {
+            help: { type: "boolean", default: false },
+            session: { type: "boolean", default: false },
+            stop: { type: "boolean", default: false },
+            command: { type: "boolean", default: false },
+            // eslint-disable-next-line @typescript-eslint/naming-convention
+            "bridge-script": { type: "string" },
+        },
+        strict: false,
+        allowPositionals: true,
+        tokens: true,
+        ...(argv !== undefined ? { args: argv } : {}),
+    });
+
+    // Walk the token stream to extract:
+    // - The first positional after --session as sessionId (if it's a number)
+    // - Remaining positionals and unknown --key value pairs into rest
+    let sessionId: string | undefined;
+    const rest: string[] = [];
+
+    if (tokens) {
+        let expectingSessionId = false;
+        let pendingOptionName: string | null = null;
+        for (const token of tokens) {
+            // After seeing --session, the next positional (if numeric) is the session id.
+            if (token.kind === "option" && token.name === "session") {
+                expectingSessionId = true;
+                continue;
+            }
+
+            if (expectingSessionId && token.kind === "positional" && !isNaN(parseInt(token.value, 10))) {
+                sessionId = token.value;
+                expectingSessionId = false;
+                continue;
+            }
+            expectingSessionId = false;
+
+            if (token.kind === "option" && !KnownOptions.has(token.name)) {
+                if (pendingOptionName !== null) {
+                    rest.push(`--${pendingOptionName}`);
+                }
+                if (token.value !== undefined) {
+                    rest.push(`--${token.name}`, token.value);
+                } else {
+                    pendingOptionName = token.name;
+                }
+                continue;
+            }
+            if (token.kind === "positional" && pendingOptionName !== null) {
+                rest.push(`--${pendingOptionName}`, token.value);
+                pendingOptionName = null;
+                continue;
+            }
+            if (token.kind === "positional") {
+                rest.push(token.value);
+            }
+        }
+        if (pendingOptionName !== null) {
+            rest.push(`--${pendingOptionName}`);
+        }
+    }
+
+    return {
+        help: !!values.help,
+        session: !!values.session,
+        sessionId,
+        stop: !!values.stop,
+        command: !!values.command,
+        bridgeScript: values["bridge-script"] as string | undefined,
+        rest,
+    };
+}
+
+async function ConnectToBridge(port: number): Promise<WebSocket> {
+    return await new Promise((resolve, reject) => {
+        const socket = new WebSocket(`ws://127.0.0.1:${port}`);
+        socket.on("open", () => resolve(socket));
+        socket.on("error", (err) => reject(err));
+    });
+}
+
+/**
+ * Sends a JSON message to the bridge over WebSocket and waits for a response.
+ * @param socket The WebSocket connection to the bridge.
+ * @param message The CLI request to send.
+ * @returns The parsed bridge response.
+ */
+export async function SendAndReceive<T extends CliResponse>(socket: WebSocket, message: CliRequest): Promise<T> {
+    return await new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => {
+            reject(new Error("Timeout waiting for bridge response."));
+        }, 15000);
+
+        socket.once("message", (data) => {
+            clearTimeout(timeout);
+            try {
+                resolve(JSON.parse(data.toString()) as T);
+            } catch {
+                reject(new Error("Failed to parse bridge response."));
+            }
+        });
+
+        socket.send(JSON.stringify(message));
+    });
+}
+
+function SpawnBridge(bridgeScript?: string): void {
+    const bridgePath = bridgeScript ? resolve(bridgeScript) : join(dirname(fileURLToPath(import.meta.url)), "inspector-bridge.mjs");
+    const child = spawn(process.execPath, [bridgePath], {
+        detached: true,
+        stdio: "ignore",
+    });
+    child.unref();
+}
+
+async function EnsureBridge(port: number, bridgeScript?: string, maxRetries = 10, retryDelayMs = 500): Promise<WebSocket> {
+    try {
+        return await ConnectToBridge(port);
+    } catch {
+        // Bridge not running — spawn it.
+        SpawnBridge(bridgeScript);
+    }
+
+    for (let i = 0; i < maxRetries; i++) {
+        // eslint-disable-next-line no-await-in-loop
+        await new Promise((resolve) => setTimeout(resolve, retryDelayMs));
+        try {
+            // eslint-disable-next-line no-await-in-loop
+            return await ConnectToBridge(port);
+        } catch {
+            // Keep retrying.
+        }
+    }
+
+    throw new Error(`Unable to connect to the Inspector bridge on port ${port} after spawning it.`);
+}
+
+/**
+ * Connects to the bridge, runs the provided callback, and closes the socket.
+ * @param bridgeScript Optional path to the bridge script.
+ * @param fn The callback to run with the connected socket.
+ */
+async function WithBridge(bridgeScript: string | undefined, fn: (socket: WebSocket) => Promise<void>): Promise<void> {
+    const socket = await EnsureBridge(Config.cliPort, bridgeScript);
+    try {
+        await fn(socket);
+    } finally {
+        socket.close();
+    }
+}
+
+/**
+ * Resolves the session id to use. If an explicit id is provided, returns it.
+ * If not, queries the bridge: returns the sole session's id when exactly one
+ * is active, or errors if zero or multiple sessions are active.
+ * @param socket The WebSocket connection to the bridge.
+ * @param explicitId An optional explicit session id string.
+ * @returns The resolved numeric session id.
+ */
+/**
+ * Parses and validates an explicit session id string against the list of active sessions.
+ * @param explicitId The session id string to validate.
+ * @param sessions The list of active sessions from the bridge.
+ * @returns The matching session info.
+ */
+export function ValidateSessionId(explicitId: string, sessions: SessionInfo[]): SessionInfo {
+    const parsed = parseInt(explicitId, 10);
+    if (isNaN(parsed)) {
+        throw new Error("Session id must be a number.");
+    }
+    const match = sessions.find((s) => s.id === parsed);
+    if (!match) {
+        if (sessions.length === 0) {
+            throw new Error(`Session ${parsed} does not exist. No active sessions.`);
+        }
+        const list = sessions.map((s) => `  [${s.id}] ${s.name}`).join("\n");
+        throw new Error(`Session ${parsed} does not exist. Active sessions:\n${list}`);
+    }
+    return match;
+}
+
+/**
+ * Resolves the session id to use. If an explicit id is provided, validates it
+ * against the active sessions. If not, queries the bridge: returns the sole
+ * session's id when exactly one is active, or errors if zero or multiple.
+ * @param socket The WebSocket connection to the bridge.
+ * @param explicitId An optional explicit session id string.
+ * @returns The resolved numeric session id.
+ */
+export async function ResolveSessionId(socket: WebSocket, explicitId?: string): Promise<number> {
+    const response = await SendAndReceive<SessionsResponse>(socket, { type: "sessions" });
+
+    if (explicitId !== undefined) {
+        return ValidateSessionId(explicitId, response.sessions).id;
+    }
+
+    if (response.sessions.length === 0) {
+        throw new Error("No active sessions. Make sure a browser is running with StartInspectable enabled.");
+    }
+    if (response.sessions.length > 1) {
+        const list = response.sessions.map((s) => `  [${s.id}] ${s.name}`).join("\n");
+        throw new Error(`Multiple active sessions:\n${list}\nSpecify a session id with --session <session-id>`);
+    }
+    return response.sessions[0].id;
+}
+
+/**
+ * Parses command arguments from the rest array (everything after the command id).
+ * @param rest The remaining CLI tokens after the command id.
+ * @param globalHelp Whether --help was specified at the top level.
+ * @returns The parsed command arguments and whether help was requested.
+ */
+export function ParseCommandArgs(rest: string[], globalHelp: boolean): { args: Record<string, string>; wantsHelp: boolean } {
+    const args: Record<string, string> = {};
+    let wantsHelp = globalHelp;
+    for (let i = 1; i < rest.length; i++) {
+        const token = rest[i];
+        if (token === "--help") {
+            wantsHelp = true;
+        } else if (token.startsWith("--") && i + 1 < rest.length) {
+            args[token.slice(2)] = rest[++i];
+        }
+    }
+    return { args, wantsHelp };
+}
+
+/**
+ * Prints help text for a command, including its description and argument list.
+ * If there are missing required arguments and help was not explicitly requested,
+ * prints an error and sets a non-zero exit code.
+ * @param commandId The command identifier.
+ * @param descriptor The command descriptor.
+ * @param missingRequired The list of missing required arguments.
+ * @param wantsHelp Whether help was explicitly requested.
+ */
+export function PrintCommandHelp(commandId: string, descriptor: CommandInfo, missingRequired: CommandArgInfo[], wantsHelp: boolean): void {
+    if (missingRequired.length > 0 && !wantsHelp) {
+        console.error(`Missing required argument(s): ${missingRequired.map((a) => `--${a.name}`).join(", ")}\n`);
+    }
+    console.log(`${commandId}: ${descriptor.description}\n`);
+    if (descriptor.args && descriptor.args.length > 0) {
+        console.log("Arguments:");
+        const maxLen = Math.max(...descriptor.args.map((a) => `--${a.name}${a.required ? " (required)" : ""}`.length));
+        for (const arg of descriptor.args) {
+            const label = `--${arg.name}${arg.required ? " (required)" : ""}`;
+            console.log(`  ${label.padEnd(maxLen)}  ${arg.description}`);
+        }
+    }
+    if (missingRequired.length > 0 && !wantsHelp) {
+        process.exitCode = 1;
+    }
+}
+
+/**
+ * Handles `--session` without `--command`: lists active sessions, or shows
+ * details for a specific session when an explicit id is provided.
+ * @param socket The WebSocket connection to the bridge.
+ * @param explicitId An optional explicit session id string.
+ */
+async function HandleSessions(socket: WebSocket, explicitId?: string): Promise<void> {
+    const response = await SendAndReceive<SessionsResponse>(socket, { type: "sessions" });
+
+    if (explicitId !== undefined) {
+        const match = ValidateSessionId(explicitId, response.sessions);
+        console.log(`  [${match.id}] ${match.name} (connected: ${match.connectedAt})`);
+        return;
+    }
+
+    if (response.sessions.length === 0) {
+        console.log("No active sessions.");
+    } else {
+        console.log("Active sessions:");
+        for (const session of response.sessions) {
+            console.log(`  [${session.id}] ${session.name} (connected: ${session.connectedAt})`);
+        }
+    }
+}
+
+/**
+ * Handles `--command`: lists commands or executes one.
+ * @param socket The WebSocket connection to the bridge.
+ * @param args The parsed CLI arguments.
+ */
+async function HandleCommand(socket: WebSocket, args: IParsedArgs): Promise<void> {
+    const commandId = args.rest.length > 0 ? args.rest[0] : undefined;
+
+    if (!commandId) {
+        // --command with no id: list available commands.
+        const sessionId = await ResolveSessionId(socket, args.sessionId);
+        const response = await SendAndReceive<CommandsResponse>(socket, { type: "commands", sessionId });
+        if (response.error) {
+            console.error(`Error: ${response.error}`);
+            process.exitCode = 1;
+            return;
+        }
+        if (!response.commands || response.commands.length === 0) {
+            console.log("No commands available.");
+        } else {
+            console.log("Available commands:");
+            const maxLen = Math.max(...response.commands.map((c) => c.id.length));
+            for (const cmd of response.commands) {
+                console.log(`  ${cmd.id.padEnd(maxLen)}  ${cmd.description}`);
+            }
+            console.log("\nRun --command <id> --help to see arguments for a command.");
+            console.log("Run --command <id> [--arg value ...] to execute a command.");
+        }
+        return;
+    }
+
+    const sessionId = await ResolveSessionId(socket, args.sessionId);
+    const { args: commandArgs, wantsHelp } = ParseCommandArgs(args.rest, args.help);
+
+    // Fetch the command descriptor to check for --help or missing required args.
+    const commandsResponse = await SendAndReceive<CommandsResponse>(socket, { type: "commands", sessionId });
+    const descriptor = commandsResponse.commands?.find((c) => c.id === commandId);
+
+    if (!descriptor) {
+        console.error(`Error: Unknown command "${commandId}".`);
+        process.exitCode = 1;
+        return;
+    }
+
+    // Check for --help or missing required arguments.
+    const missingRequired = (descriptor.args ?? []).filter((a) => a.required && !(a.name in commandArgs));
+    if (wantsHelp || missingRequired.length > 0) {
+        PrintCommandHelp(commandId, descriptor, missingRequired, wantsHelp);
+        return;
+    }
+
+    const response = await SendAndReceive<ExecResponse>(socket, {
+        type: "exec",
+        sessionId,
+        commandId,
+        args: commandArgs,
+    });
+    if (response.error) {
+        console.error(`Error: ${response.error}`);
+        process.exitCode = 1;
+    } else {
+        console.log(response.result ?? "");
+    }
+}
+
+async function Main(): Promise<void> {
+    const args = ParseCliArgs();
+
+    if (args.help && !args.command) {
+        console.log(HELP_TEXT);
+        return;
+    }
+
+    if (args.stop) {
+        try {
+            const socket = await ConnectToBridge(Config.cliPort);
+            await SendAndReceive(socket, { type: "stop" });
+            socket.close();
+            console.log("Bridge stopped.");
+        } catch {
+            console.log("Bridge is not running.");
+        }
+        return;
+    }
+
+    if (args.session && !args.command) {
+        await WithBridge(args.bridgeScript, async (socket) => await HandleSessions(socket, args.sessionId));
+        return;
+    }
+
+    if (args.command) {
+        await WithBridge(args.bridgeScript, async (socket) => await HandleCommand(socket, args));
+        return;
+    }
+
+    // No recognized option — show help.
+    console.log(HELP_TEXT);
+}
+
+void (async () => {
+    try {
+        await Main();
+    } catch (error: unknown) {
+        console.error(`Error: ${error}`);
+        process.exitCode = 1;
+    }
+})();
diff --git a/packages/dev/inspector-v2/src/cli/config.ts b/packages/dev/inspector-v2/src/cli/config.ts
new file mode 100644
index 000000000000..3cc9e091bf9f
--- /dev/null
+++ b/packages/dev/inspector-v2/src/cli/config.ts
@@ -0,0 +1,76 @@
+import { existsSync, readFileSync } from "fs";
+import { dirname, join } from "path";
+
+const CONFIG_FILENAME = ".babyloninspector";
+
+const DefaultBrowserPort = 4400;
+const DefaultCliPort = 4401;
+
+/**
+ * Configuration for the Inspector CLI bridge.
+ */
+export interface IInspectorBridgeConfig {
+    /**
+     * WebSocket port for browser sessions to connect to the bridge.
+     */
+    browserPort: number;
+
+    /**
+     * WebSocket port for CLI connections to the bridge.
+     */
+    cliPort: number;
+}
+
+/**
+ * Searches for a `.babyloninspector` config file starting from the given directory
+ * and walking up the parent chain. Returns the path to the first file found, or
+ * undefined if none is found.
+ * @param startDir The directory to start searching from.
+ * @returns The absolute path to the config file, or undefined.
+ */
+function FindConfigFile(startDir: string): string | undefined {
+    let current = startDir;
+    for (;;) {
+        const candidate = join(current, CONFIG_FILENAME);
+        if (existsSync(candidate)) {
+            return candidate;
+        }
+        const parent = dirname(current);
+        if (parent === current) {
+            // Reached filesystem root.
+            return undefined;
+        }
+        current = parent;
+    }
+}
+
+/**
+ * Loads the Inspector bridge configuration by searching for a `.babyloninspector`
+ * file in the directory parent chain starting from `cwd`. If no file is found,
+ * or if fields are missing, defaults are used.
+ * @param cwd The working directory to start the search from. Defaults to `process.cwd()`.
+ * @returns The resolved configuration.
+ */
+export function LoadConfig(cwd?: string): IInspectorBridgeConfig {
+    const defaults: IInspectorBridgeConfig = {
+        browserPort: DefaultBrowserPort,
+        cliPort: DefaultCliPort,
+    };
+
+    const configPath = FindConfigFile(cwd ?? process.cwd());
+    if (!configPath) {
+        return defaults;
+    }
+
+    try {
+        const raw = readFileSync(configPath, "utf-8");
+        const parsed = JSON.parse(raw) as Partial<IInspectorBridgeConfig>;
+        return {
+            browserPort: typeof parsed.browserPort === "number" ? parsed.browserPort : defaults.browserPort,
+            cliPort: typeof parsed.cliPort === "number" ? parsed.cliPort : defaults.cliPort,
+        };
+    } catch {
+        // If the file is malformed, fall back to defaults.
+        return defaults;
+    }
+}
diff --git a/packages/dev/inspector-v2/src/cli/protocol.ts b/packages/dev/inspector-v2/src/cli/protocol.ts
new file mode 100644
index 000000000000..9d87995eef77
--- /dev/null
+++ b/packages/dev/inspector-v2/src/cli/protocol.ts
@@ -0,0 +1,205 @@
+// ---- Shared types ----
+
+/**
+ * Serializable description of a command argument, used in protocol messages.
+ */
+export type CommandArgInfo = {
+    /** The name of the argument. */
+    name: string;
+    /** A human-readable description of the argument. */
+    description: string;
+    /** Whether this argument is required. */
+    required?: boolean;
+};
+
+/**
+ * Serializable description of a command, used in protocol messages.
+ */
+export type CommandInfo = {
+    /** A unique identifier for the command. */
+    id: string;
+    /** A human-readable description of the command. */
+    description: string;
+    /** The arguments this command accepts. */
+    args?: CommandArgInfo[];
+};
+
+/**
+ * Serializable description of a session, used in protocol messages.
+ */
+export type SessionInfo = {
+    /** The numeric session identifier. */
+    id: number;
+    /** The display name of the session. */
+    name: string;
+    /** ISO 8601 timestamp of when the session connected. */
+    connectedAt: string;
+};
+
+// ---- CLI ↔ Bridge (CLI port) ----
+
+/**
+ * CLI → Bridge: Request the list of active browser sessions.
+ */
+export type SessionsRequest = {
+    /** The message type discriminator. */
+    type: "sessions";
+};
+
+/**
+ * CLI → Bridge: Request the list of commands available from a session.
+ */
+export type CommandsRequest = {
+    /** The message type discriminator. */
+    type: "commands";
+    /** The session to query for commands. */
+    sessionId: number;
+};
+
+/**
+ * CLI → Bridge: Execute a command on a session.
+ */
+export type ExecRequest = {
+    /** The message type discriminator. */
+    type: "exec";
+    /** The session to execute the command on. */
+    sessionId: number;
+    /** The identifier of the command to execute. */
+    commandId: string;
+    /** Key-value pairs of arguments for the command. */
+    args: Record<string, string>;
+};
+
+/**
+ * CLI → Bridge: Stop the bridge process.
+ */
+export type StopRequest = {
+    /** The message type discriminator. */
+    type: "stop";
+};
+
+/**
+ * All messages that the CLI sends to the bridge.
+ */
+export type CliRequest = SessionsRequest | CommandsRequest | ExecRequest | StopRequest;
+
+/**
+ * Bridge → CLI: Response with the list of active sessions.
+ */
+export type SessionsResponse = {
+    /** The message type discriminator. */
+    type: "sessionsResponse";
+    /** The list of active sessions. */
+    sessions: SessionInfo[];
+};
+
+/**
+ * Bridge → CLI: Response with the list of commands from a session.
+ */
+export type CommandsResponse = {
+    /** The message type discriminator. */
+    type: "commandsResponse";
+    /** The list of available commands, if successful. */
+    commands?: CommandInfo[];
+    /** An error message, if the request failed. */
+    error?: string;
+};
+
+/**
+ * Bridge → CLI: Response with the result of a command execution.
+ */
+export type ExecResponse = {
+    /** The message type discriminator. */
+    type: "execResponse";
+    /** The result of the command execution, if successful. */
+    result?: string;
+    /** An error message, if the execution failed. */
+    error?: string;
+};
+
+/**
+ * Bridge → CLI: Acknowledgement that the bridge is stopping.
+ */
+export type StopResponse = {
+    /** The message type discriminator. */
+    type: "stopResponse";
+    /** Whether the bridge stopped successfully. */
+    success: boolean;
+};
+
+/**
+ * All messages that the bridge sends to the CLI.
+ */
+export type CliResponse = SessionsResponse | CommandsResponse | ExecResponse | StopResponse;
+
+// ---- Bridge ↔ Browser (browser port) ----
+
+/**
+ * Browser → Bridge: Register a new session.
+ */
+export type RegisterRequest = {
+    /** The message type discriminator. */
+    type: "register";
+    /** The display name for this session. */
+    name: string;
+};
+
+/**
+ * Browser → Bridge: Response to a listCommands request from the bridge.
+ */
+export type CommandListResponse = {
+    /** The message type discriminator. */
+    type: "commandListResponse";
+    /** The identifier of the original request. */
+    requestId: string;
+    /** The list of registered commands. */
+    commands: CommandInfo[];
+};
+
+/**
+ * Browser → Bridge: Response to an execCommand request from the bridge.
+ */
+export type CommandResponse = {
+    /** The message type discriminator. */
+    type: "commandResponse";
+    /** The identifier of the original request. */
+    requestId: string;
+    /** The result of the command execution, if successful. */
+    result?: string;
+    /** An error message, if the execution failed. */
+    error?: string;
+};
+
+/**
+ * All messages that the browser sends to the bridge.
+ */
+export type BrowserRequest = RegisterRequest | CommandListResponse | CommandResponse;
+
+/**
+ * Bridge → Browser: Request the list of registered commands.
+ */
+export type ListCommandsRequest = {
+    /** The message type discriminator. */
+    type: "listCommands";
+    /** A unique identifier for this request. */
+    requestId: string;
+};
+
+/**
+ * Bridge → Browser: Request execution of a command.
+ */
+export type ExecCommandRequest = {
+    /** The message type discriminator. */
+    type: "execCommand";
+    /** A unique identifier for this request. */
+    requestId: string;
+    /** The identifier of the command to execute. */
+    commandId: string;
+    /** Key-value pairs of arguments for the command. */
+    args: Record<string, string>;
+};
+
+/**
+ * All messages that the bridge sends to the browser.
+ */
+export type BrowserResponse = ListCommandsRequest | ExecCommandRequest;
diff --git a/packages/dev/inspector-v2/src/cli/webSocket.ts b/packages/dev/inspector-v2/src/cli/webSocket.ts
new file mode 100644
index 000000000000..40c333e38294
--- /dev/null
+++ b/packages/dev/inspector-v2/src/cli/webSocket.ts
@@ -0,0 +1,20 @@
+/**
+ * Re-exports WebSocket and WebSocketServer from the ws package.
+ *
+ * ws is a CJS module — named exports like WebSocketServer aren't available
+ * at runtime when Node auto-detects ESM from tsc output. This module works
+ * around that by extracting them from the default export and re-exporting
+ * them as merged type+value pairs.
+ */
+import ws from "ws";
+
+export const WebSocket = ws;
+export type WebSocket = import("ws").WebSocket;
+
+export const WebSocketServer = (
+    ws as unknown as {
+        // eslint-disable-next-line @typescript-eslint/naming-convention
+        Server: new (options?: import("ws").ServerOptions) => import("ws").WebSocketServer;
+    }
+).Server;
+export type WebSocketServer = import("ws").WebSocketServer;
diff --git a/packages/dev/inspector-v2/src/components/stats/performanceStats.tsx b/packages/dev/inspector-v2/src/components/stats/performanceStats.tsx
index 71889afa2f57..c91c243b5dea 100644
--- a/packages/dev/inspector-v2/src/components/stats/performanceStats.tsx
+++ b/packages/dev/inspector-v2/src/components/stats/performanceStats.tsx
@@ -15,22 +15,15 @@ import { ChildWindow } from "shared-ui-components/fluent/hoc/childWindow";
 import { FileUploadLine } from "shared-ui-components/fluent/hoc/fileUploadLine";
 import { type PerfLayoutSize } from "../performanceViewer/graphSupportingTypes";
 import { PerformanceViewer } from "../performanceViewer/performanceViewer";
+import { DefaultPerfStrategies, PerfMetadataCategory } from "../../misc/defaultPerfStrategies";
 
+/**
+ * Adds default and platform-specific performance collection strategies to the collector.
+ * @param perfCollector - The performance viewer collector to add strategies to.
+ */
 function AddStrategies(perfCollector: PerformanceViewerCollector) {
-    perfCollector.addCollectionStrategies(...DefaultStrategiesList);
+    perfCollector.addCollectionStrategies(...DefaultPerfStrategies);
     if (PressureObserverWrapper.IsAvailable) {
-        // Do not enable for now as the Pressure API does not
-        // report factors at the moment.
-        // perfCollector.addCollectionStrategies({
-        //     strategyCallback: PerfCollectionStrategy.ThermalStrategy(),
-        //     category: IPerfMetadataCategory.FrameSteps,
-        //     hidden: true,
-        // });
-        // perfCollector.addCollectionStrategies({
-        //     strategyCallback: PerfCollectionStrategy.PowerSupplyStrategy(),
-        //     category: IPerfMetadataCategory.FrameSteps,
-        //     hidden: true,
-        // });
         perfCollector.addCollectionStrategies({
             strategyCallback: PerfCollectionStrategy.PressureStrategy(),
             category: PerfMetadataCategory.FrameSteps,
@@ -39,37 +32,6 @@ function AddStrategies(perfCollector: PerformanceViewerCollector) {
     }
 }
 
-const enum PerfMetadataCategory {
-    Count = "Count",
-    FrameSteps = "Frame Steps Duration",
-}
-
-// list of strategies to add to perf graph automatically.
-const DefaultStrategiesList = [
-    { strategyCallback: PerfCollectionStrategy.FpsStrategy() },
-    { strategyCallback: PerfCollectionStrategy.TotalMeshesStrategy(), category: PerfMetadataCategory.Count, hidden: true },
-    { strategyCallback: PerfCollectionStrategy.ActiveMeshesStrategy(), category: PerfMetadataCategory.Count, hidden: true },
-    { strategyCallback: PerfCollectionStrategy.ActiveIndicesStrategy(), category: PerfMetadataCategory.Count, hidden: true },
-    { strategyCallback: PerfCollectionStrategy.ActiveBonesStrategy(), category: PerfMetadataCategory.Count, hidden: true },
-    { strategyCallback: PerfCollectionStrategy.ActiveParticlesStrategy(), category: PerfMetadataCategory.Count, hidden: true },
-    { strategyCallback: PerfCollectionStrategy.DrawCallsStrategy(), category: PerfMetadataCategory.Count, hidden: true },
-    { strategyCallback: PerfCollectionStrategy.TotalLightsStrategy(), category: PerfMetadataCategory.Count, hidden: true },
-    { strategyCallback: PerfCollectionStrategy.TotalVerticesStrategy(), category: PerfMetadataCategory.Count, hidden: true },
-    { strategyCallback: PerfCollectionStrategy.TotalMaterialsStrategy(), category: PerfMetadataCategory.Count, hidden: true },
-    { strategyCallback: PerfCollectionStrategy.TotalTexturesStrategy(), category: PerfMetadataCategory.Count, hidden: true },
-    { strategyCallback: PerfCollectionStrategy.AbsoluteFpsStrategy(), category: PerfMetadataCategory.FrameSteps, hidden: true },
-    { strategyCallback: PerfCollectionStrategy.MeshesSelectionStrategy(), category: PerfMetadataCategory.FrameSteps, hidden: true },
-    { strategyCallback: PerfCollectionStrategy.RenderTargetsStrategy(), category: PerfMetadataCategory.FrameSteps, hidden: true },
-    { strategyCallback: PerfCollectionStrategy.ParticlesStrategy(), category: PerfMetadataCategory.FrameSteps, hidden: true },
-    { strategyCallback: PerfCollectionStrategy.SpritesStrategy(), category: PerfMetadataCategory.FrameSteps, hidden: true },
-    { strategyCallback: PerfCollectionStrategy.AnimationsStrategy(), category: PerfMetadataCategory.FrameSteps, hidden: true },
-    { strategyCallback: PerfCollectionStrategy.PhysicsStrategy(), category: PerfMetadataCategory.FrameSteps, hidden: true },
-    { strategyCallback: PerfCollectionStrategy.RenderStrategy(), category: PerfMetadataCategory.FrameSteps, hidden: true },
-    { strategyCallback: PerfCollectionStrategy.FrameTotalStrategy(), category: PerfMetadataCategory.FrameSteps, hidden: true },
-    { strategyCallback: PerfCollectionStrategy.InterFrameStrategy(), category: PerfMetadataCategory.FrameSteps, hidden: true },
-    { strategyCallback: PerfCollectionStrategy.GpuFrameTimeStrategy(), category: PerfMetadataCategory.FrameSteps, hidden: true },
-] as const;
-
 // arbitrary window size
 const InitialWindowSize = { width: 1024, height: 512 };
 const InitialGraphSize = new Vector2(724, 512);
diff --git a/packages/dev/inspector-v2/src/index.ts b/packages/dev/inspector-v2/src/index.ts
index c2d12770597f..60c7f18b2b29 100644
--- a/packages/dev/inspector-v2/src/index.ts
+++ b/packages/dev/inspector-v2/src/index.ts
@@ -48,6 +48,9 @@ export * from "./services/selectionService";
 export type { IShellService, ToolbarItemDefinition, SidePaneDefinition, CentralContentDefinition } from "./services/shellService";
 export { ShellServiceIdentity } from "./services/shellService";
 export * from "./inspector";
+export { StartInspectable, type InspectableToken, type InspectableOptions } from "./inspectable";
+export type { IInspectableCommandRegistry, InspectableCommandDescriptor, InspectableCommandArg } from "./services/cli/inspectableCommandRegistry";
+export { InspectableCommandRegistryIdentity } from "./services/cli/inspectableCommandRegistry";
 export { ConvertOptions, Inspector } from "./legacy/inspector";
 export { AttachDebugLayer, DetachDebugLayer } from "./legacy/debugLayer";
 
diff --git a/packages/dev/inspector-v2/src/inspectable.ts b/packages/dev/inspector-v2/src/inspectable.ts
new file mode 100644
index 000000000000..8e27e80e751c
--- /dev/null
+++ b/packages/dev/inspector-v2/src/inspectable.ts
@@ -0,0 +1,222 @@
+import { type IDisposable, type Nullable } from "core/index";
+import { Logger } from "core/Misc/logger";
+import { Observable } from "core/Misc/observable";
+import { type Scene } from "core/scene";
+import { type WeaklyTypedServiceDefinition, ServiceContainer } from "./modularity/serviceContainer";
+import { type ServiceDefinition } from "./modularity/serviceDefinition";
+import { EntityQueryServiceDefinition } from "./services/cli/entityQueryService";
+import { MakeInspectableBridgeServiceDefinition } from "./services/cli/inspectableBridgeService";
+import { PerfTraceCommandServiceDefinition } from "./services/cli/perfTraceCommandService";
+import { ScreenshotCommandServiceDefinition } from "./services/cli/screenshotCommandService";
+import { ShaderCommandServiceDefinition } from "./services/cli/shaderCommandService";
+import { StatsCommandServiceDefinition } from "./services/cli/statsCommandService";
+import { type ISceneContext, SceneContextIdentity } from "./services/sceneContext";
+
+const DefaultPort = 4400;
+
+/**
+ * Options for making a scene inspectable via the Inspector CLI.
+ */
+export type InspectableOptions = {
+    /**
+     * WebSocket port for the bridge's browser port. Defaults to 4400.
+     */
+    port?: number;
+
+    /**
+     * Session display name reported to the bridge. Defaults to `document.title`.
+     */
+    name?: string;
+
+    /**
+     * Additional service definitions to register with the inspectable container.
+     * These are added in a separate call from the built-in services and are removed
+     * when the returned token is disposed.
+     */
+    serviceDefinitions?: readonly WeaklyTypedServiceDefinition[];
+};
+
+/**
+ * A token returned by {@link StartInspectable} that can be disposed to disconnect
+ * the scene from the Inspector CLI bridge.
+ */
+export type InspectableToken = IDisposable & {
+    /**
+     * Whether this token has been disposed.
+     */
+    readonly isDisposed: boolean;
+};
+
+/**
+ * @internal
+ * An internal token that also exposes the underlying ServiceContainer,
+ * allowing ShowInspector to use it as a parent container.
+ */
+export type InternalInspectableToken = InspectableToken & {
+    /**
+     * The ServiceContainer backing this inspectable session.
+     */
+    readonly serviceContainer: ServiceContainer;
+};
+
+// Track shared state per scene: the service container, ref count, and teardown logic.
+type InspectableState = {
+    refCount: number;
+    serviceContainer: ServiceContainer;
+    sceneDisposeObserver: { remove: () => void };
+    fullyDispose: () => void;
+    /** Resolves when the built-in services have been initialized. Rejects if initialization fails. */
+    readyPromise: Promise<void>;
+};
+
+const InspectableStates = new Map<Scene, InspectableState>();
+
+/**
+ * @internal
+ * Internal implementation that returns an {@link InternalInspectableToken} with access
+ * to the underlying ServiceContainer. Used by ShowInspector to set up a parent container relationship.
+ */
+export function _StartInspectable(scene: Scene, options?: Partial<InspectableOptions>): InternalInspectableToken {
+    let state = InspectableStates.get(scene);
+
+    if (!state) {
+        const port = options?.port ?? DefaultPort;
+        const name = options?.name ?? (typeof document !== "undefined" ? document.title : "Babylon.js Scene");
+
+        const serviceContainer = new ServiceContainer("InspectableContainer");
+
+        const fullyDispose = () => {
+            InspectableStates.delete(scene);
+            serviceContainer.dispose();
+            sceneDisposeObserver.remove();
+        };
+
+        // Initialize the service container asynchronously.
+        const sceneContextServiceDefinition: ServiceDefinition<[ISceneContext], []> = {
+            friendlyName: "Inspectable Scene Context",
+            produces: [SceneContextIdentity],
+            factory: () => ({
+                currentScene: scene,
+                currentSceneObservable: new Observable<Nullable<Scene>>(),
+            }),
+        };
+
+        const readyPromise = (async () => {
+            await serviceContainer.addServicesAsync(
+                sceneContextServiceDefinition,
+                MakeInspectableBridgeServiceDefinition({
+                    port,
+                    name,
+                }),
+                EntityQueryServiceDefinition,
+                ScreenshotCommandServiceDefinition,
+                ShaderCommandServiceDefinition,
+                StatsCommandServiceDefinition,
+                PerfTraceCommandServiceDefinition
+            );
+        })();
+
+        state = {
+            refCount: 0,
+            serviceContainer,
+            sceneDisposeObserver: { remove: () => {} },
+            fullyDispose,
+            readyPromise,
+        };
+
+        const capturedState = state;
+
+        InspectableStates.set(scene, state);
+
+        // Auto-dispose when the scene is disposed.
+        const sceneDisposeObserver = scene.onDisposeObservable.addOnce(() => {
+            capturedState.refCount = 0;
+            capturedState.fullyDispose();
+        });
+        state.sceneDisposeObserver = sceneDisposeObserver;
+
+        // Handle initialization failure (guard against already-disposed state).
+        void (async () => {
+            try {
+                await readyPromise;
+            } catch (error: unknown) {
+                if (InspectableStates.has(scene)) {
+                    Logger.Error(`Failed to initialize Inspectable: ${error}`);
+                    capturedState.refCount = 0;
+                    capturedState.fullyDispose();
+                }
+            }
+        })();
+    }
+
+    state.refCount++;
+    const { serviceContainer } = state;
+    const owningState = state;
+
+    // If additional service definitions were provided, add them in a separate call
+    // so they can be independently removed when this token is disposed.
+    let extraServicesDisposable: IDisposable | undefined;
+    const extraAbortController = new AbortController();
+    const extraServiceDefinitions = options?.serviceDefinitions;
+    if (extraServiceDefinitions && extraServiceDefinitions.length > 0) {
+        // Wait for the built-in services to be ready, then add the extra ones.
+        void (async () => {
+            try {
+                await owningState.readyPromise;
+                extraServicesDisposable = await serviceContainer.addServicesAsync(...extraServiceDefinitions, extraAbortController.signal);
+            } catch (error: unknown) {
+                if (!extraAbortController.signal.aborted) {
+                    Logger.Error(`Failed to add extra inspectable services: ${error}`);
+                }
+            }
+        })();
+    }
+
+    let disposed = false;
+    const token: InternalInspectableToken = {
+        get isDisposed() {
+            return disposed;
+        },
+        get serviceContainer() {
+            return serviceContainer;
+        },
+        dispose() {
+            if (disposed) {
+                return;
+            }
+            disposed = true;
+
+            // Abort any in-flight extra service initialization and remove already-added extra services.
+            extraAbortController.abort();
+            extraServicesDisposable?.dispose();
+
+            owningState.refCount--;
+            if (owningState.refCount <= 0) {
+                owningState.fullyDispose();
+            }
+        },
+    };
+
+    return token;
+}
+
+/**
+ * Makes a scene inspectable by connecting it to the Inspector CLI bridge.
+ * This creates a headless {@link ServiceContainer} (no UI) and registers the
+ * {@link InspectableBridgeService} which opens a WebSocket to the bridge and
+ * exposes a command registry for CLI-invocable commands.
+ *
+ * Multiple callers may call this for the same scene. Each returned token is
+ * ref-counted — the underlying connection is only torn down when all tokens
+ * have been disposed. Additional {@link InspectableOptions.serviceDefinitions}
+ * passed by each caller are added to the shared container and removed when
+ * that caller's token is disposed.
+ *
+ * @param scene The scene to make inspectable.
+ * @param options Optional configuration.
+ * @returns An {@link InspectableToken} that can be disposed to disconnect.
+ * @experimental
+ */
+export function StartInspectable(scene: Scene, options?: Partial<InspectableOptions>): InspectableToken {
+    return _StartInspectable(scene, options);
+}
diff --git a/packages/dev/inspector-v2/src/inspector.tsx b/packages/dev/inspector-v2/src/inspector.tsx
index 0986d2d50b88..c8a05101a21b 100644
--- a/packages/dev/inspector-v2/src/inspector.tsx
+++ b/packages/dev/inspector-v2/src/inspector.tsx
@@ -1,8 +1,7 @@
-import { type IDisposable, type IReadonlyObservable, type Nullable, type Scene } from "core/index";
+import { type IDisposable, type IReadonlyObservable, type Scene } from "core/index";
 import { type WeaklyTypedServiceDefinition } from "./modularity/serviceContainer";
 import { type ServiceDefinition } from "./modularity/serviceDefinition";
 import { type ModularToolOptions, MakeModularTool } from "./modularTool";
-import { type ISceneContext, SceneContextIdentity } from "./services/sceneContext";
 import { type IShellService, ShellServiceIdentity } from "./services/shellService";
 
 import { AsyncLock } from "core/Misc/asyncLock";
@@ -10,7 +9,9 @@ import { Logger } from "core/Misc/logger";
 import { Observable } from "core/Misc/observable";
 import { useEffect, useRef } from "react";
 import { DefaultInspectorExtensionFeed } from "./extensibility/defaultInspectorExtensionFeed";
+import { _StartInspectable } from "./inspectable";
 import { LegacyInspectableObjectPropertiesServiceDefinition } from "./legacy/inspectableCustomPropertiesService";
+import { CliConnectionStatusServiceDefinition } from "./services/cliConnectionStatusService";
 import { GizmoServiceDefinition } from "./services/gizmoService";
 import { GizmoToolbarServiceDefinition } from "./services/gizmoToolbarService";
 import { HighlightServiceDefinition } from "./services/highlightService";
@@ -228,6 +229,12 @@ export function ShowInspector(scene: Scene, options: Partial<InspectorOptions> =
         // This array will contain all the default Inspector service definitions.
         const serviceDefinitions: WeaklyTypedServiceDefinition[] = [];
 
+        // Ensure the inspectable bridge is running for this scene. The inspector's
+        // ServiceContainer will use the inspectable container as a parent, inheriting
+        // services like ISceneContext and IInspectableCommandRegistry.
+        const inspectableToken = _StartInspectable(scene);
+        disposeActions.push(() => inspectableToken.dispose());
+
         // Create a container element for the inspector UI.
         // This element will become the root React node, so it must be a new empty node
         // since React will completely take over its contents.
@@ -285,19 +292,6 @@ export function ShowInspector(scene: Scene, options: Partial<InspectorOptions> =
             parentElement.removeChild(containerElement);
         });
 
-        // This service exposes the scene that was passed into Inspector through ISceneContext, which is used by other services that may be used in other contexts outside of Inspector.
-        const sceneContextServiceDefinition: ServiceDefinition<[ISceneContext], []> = {
-            friendlyName: "Inspector Scene Context",
-            produces: [SceneContextIdentity],
-            factory: () => {
-                return {
-                    currentScene: scene,
-                    currentSceneObservable: new Observable<Nullable<Scene>>(),
-                };
-            },
-        };
-        serviceDefinitions.push(sceneContextServiceDefinition);
-
         if (options.autoResizeEngine) {
             const observer = scene.onBeforeRenderObservable.add(() => scene.getEngine().resize());
             disposeActions.push(() => observer.remove());
@@ -392,6 +386,9 @@ export function ShowInspector(scene: Scene, options: Partial<InspectorOptions> =
             // Adds entry points for user feedback on Inspector v2 (probably eventually will be removed).
             UserFeedbackServiceDefinition,
 
+            // Shows CLI bridge connection status in the toolbar.
+            CliConnectionStatusServiceDefinition,
+
             // Adds always present "mini stats" (like fps) to the toolbar, etc.
             MiniStatsServiceDefinition,
 
@@ -402,6 +399,7 @@ export function ShowInspector(scene: Scene, options: Partial<InspectorOptions> =
         const modularTool = MakeModularTool({
             namespace: "Inspector",
             containerElement,
+            parentContainer: inspectableToken.serviceContainer,
             serviceDefinitions: [
                 // Default Inspector services.
                 ...serviceDefinitions,
diff --git a/packages/dev/inspector-v2/src/misc/defaultPerfStrategies.ts b/packages/dev/inspector-v2/src/misc/defaultPerfStrategies.ts
new file mode 100644
index 000000000000..c906405fddcf
--- /dev/null
+++ b/packages/dev/inspector-v2/src/misc/defaultPerfStrategies.ts
@@ -0,0 +1,43 @@
+import { PerfCollectionStrategy } from "core/Misc/PerformanceViewer/performanceViewerCollectionStrategies";
+import { type PerformanceViewerCollector } from "core/Misc/PerformanceViewer/performanceViewerCollector";
+
+/**
+ * The strategy parameter type accepted by {@link PerformanceViewerCollector.addCollectionStrategies}.
+ */
+export type PerfStrategyParameter = Parameters<PerformanceViewerCollector["addCollectionStrategies"]>[number];
+
+/**
+ * Performance metadata categories for grouping strategies.
+ */
+export const enum PerfMetadataCategory {
+    Count = "Count",
+    FrameSteps = "Frame Steps Duration",
+}
+
+/**
+ * Default list of performance collection strategies used by the performance viewer and CLI perf trace.
+ */
+export const DefaultPerfStrategies: readonly PerfStrategyParameter[] = [
+    { strategyCallback: PerfCollectionStrategy.FpsStrategy() },
+    { strategyCallback: PerfCollectionStrategy.TotalMeshesStrategy(), category: PerfMetadataCategory.Count, hidden: true },
+    { strategyCallback: PerfCollectionStrategy.ActiveMeshesStrategy(), category: PerfMetadataCategory.Count, hidden: true },
+    { strategyCallback: PerfCollectionStrategy.ActiveIndicesStrategy(), category: PerfMetadataCategory.Count, hidden: true },
+    { strategyCallback: PerfCollectionStrategy.ActiveBonesStrategy(), category: PerfMetadataCategory.Count, hidden: true },
+    { strategyCallback: PerfCollectionStrategy.ActiveParticlesStrategy(), category: PerfMetadataCategory.Count, hidden: true },
+    { strategyCallback: PerfCollectionStrategy.DrawCallsStrategy(), category: PerfMetadataCategory.Count, hidden: true },
+    { strategyCallback: PerfCollectionStrategy.TotalLightsStrategy(), category: PerfMetadataCategory.Count, hidden: true },
+    { strategyCallback: PerfCollectionStrategy.TotalVerticesStrategy(), category: PerfMetadataCategory.Count, hidden: true },
+    { strategyCallback: PerfCollectionStrategy.TotalMaterialsStrategy(), category: PerfMetadataCategory.Count, hidden: true },
+    { strategyCallback: PerfCollectionStrategy.TotalTexturesStrategy(), category: PerfMetadataCategory.Count, hidden: true },
+    { strategyCallback: PerfCollectionStrategy.AbsoluteFpsStrategy(), category: PerfMetadataCategory.FrameSteps, hidden: true },
+    { strategyCallback: PerfCollectionStrategy.MeshesSelectionStrategy(), category: PerfMetadataCategory.FrameSteps, hidden: true },
+    { strategyCallback: PerfCollectionStrategy.RenderTargetsStrategy(), category: PerfMetadataCategory.FrameSteps, hidden: true },
+    { strategyCallback: PerfCollectionStrategy.ParticlesStrategy(), category: PerfMetadataCategory.FrameSteps, hidden: true },
+    { strategyCallback: PerfCollectionStrategy.SpritesStrategy(), category: PerfMetadataCategory.FrameSteps, hidden: true },
+    { strategyCallback: PerfCollectionStrategy.AnimationsStrategy(), category: PerfMetadataCategory.FrameSteps, hidden: true },
+    { strategyCallback: PerfCollectionStrategy.PhysicsStrategy(), category: PerfMetadataCategory.FrameSteps, hidden: true },
+    { strategyCallback: PerfCollectionStrategy.RenderStrategy(), category: PerfMetadataCategory.FrameSteps, hidden: true },
+    { strategyCallback: PerfCollectionStrategy.FrameTotalStrategy(), category: PerfMetadataCategory.FrameSteps, hidden: true },
+    { strategyCallback: PerfCollectionStrategy.InterFrameStrategy(), category: PerfMetadataCategory.FrameSteps, hidden: true },
+    { strategyCallback: PerfCollectionStrategy.GpuFrameTimeStrategy(), category: PerfMetadataCategory.FrameSteps, hidden: true },
+];
diff --git a/packages/dev/inspector-v2/src/modularTool.tsx b/packages/dev/inspector-v2/src/modularTool.tsx
index b8e312a66829..e24f8a9c5e16 100644
--- a/packages/dev/inspector-v2/src/modularTool.tsx
+++ b/packages/dev/inspector-v2/src/modularTool.tsx
@@ -119,6 +119,12 @@ export type ModularToolOptions = {
      * The extension feeds that provide optional extensions the user can install.
      */
     extensionFeeds?: readonly IExtensionFeed[];
+
+    /**
+     * An optional parent ServiceContainer. Dependencies not found in the tool's own container
+     * will be resolved from this parent.
+     */
+    parentContainer?: ServiceContainer;
 } & ShellServiceOptions;
 
 /**
@@ -127,7 +133,7 @@ export type ModularToolOptions = {
  * @returns A token that can be used to dispose of the tool.
  */
 export function MakeModularTool(options: ModularToolOptions): IDisposable {
-    const { namespace, containerElement, serviceDefinitions, themeMode, showThemeSelector = true, extensionFeeds = [] } = options;
+    const { namespace, containerElement, serviceDefinitions, themeMode, showThemeSelector = true, extensionFeeds = [], parentContainer } = options;
 
     // Create the settings store immediately as it will be exposed to services and through React context.
     const settingsStore = new SettingsStore(namespace);
@@ -160,7 +166,7 @@ export function MakeModularTool(options: ModularToolOptions): IDisposable {
         // This is the main async initialization.
         useEffect(() => {
             const initializeExtensionManagerAsync = async () => {
-                const serviceContainer = new ServiceContainer("ModularToolContainer");
+                const serviceContainer = new ServiceContainer("ModularToolContainer", parentContainer);
 
                 // Expose the settings store as a service so other services can read/write settings.
                 await serviceContainer.addServiceAsync<[ISettingsStore], []>({
diff --git a/packages/dev/inspector-v2/src/modularity/serviceContainer.ts b/packages/dev/inspector-v2/src/modularity/serviceContainer.ts
index 543a2e03745f..ff7a944a966d 100644
--- a/packages/dev/inspector-v2/src/modularity/serviceContainer.ts
+++ b/packages/dev/inspector-v2/src/modularity/serviceContainer.ts
@@ -40,8 +40,19 @@ export class ServiceContainer implements IDisposable {
     private readonly _serviceDefinitions = new Map<symbol, WeaklyTypedServiceDefinition>();
     private readonly _serviceDependents = new Map<WeaklyTypedServiceDefinition, Set<WeaklyTypedServiceDefinition>>();
     private readonly _serviceInstances = new Map<WeaklyTypedServiceDefinition, (IService<symbol> & Partial<IDisposable>) | void>();
+    private readonly _children = new Set<ServiceContainer>();
 
-    public constructor(private readonly _friendlyName: string) {}
+    /**
+     * Creates a new ServiceContainer.
+     * @param _friendlyName A human-readable name for debugging.
+     * @param _parent An optional parent container. Dependencies not found locally will be resolved from the parent.
+     */
+    public constructor(
+        private readonly _friendlyName: string,
+        private readonly _parent?: ServiceContainer
+    ) {
+        _parent?._children.add(this);
+    }
 
     /**
      * Adds a set of service definitions in the service container.
@@ -115,28 +126,61 @@ export class ServiceContainer implements IDisposable {
             this._serviceDefinitions.set(contract, service);
         });
 
-        const dependencies =
-            service.consumes?.map((dependency) => {
-                const dependencyDefinition = this._serviceDefinitions.get(dependency);
-                if (!dependencyDefinition) {
-                    throw new Error(`Service '${dependency.toString()}' has not been registered in the '${this._friendlyName}' container.`);
-                }
+        const dependencies = service.consumes?.map((contract) => this._resolveDependency(contract, service)) ?? [];
 
-                let dependentDefinitions = this._serviceDependents.get(dependencyDefinition);
-                if (!dependentDefinitions) {
-                    this._serviceDependents.set(dependencyDefinition, (dependentDefinitions = new Set()));
-                }
-                dependentDefinitions.add(service);
+        this._serviceInstances.set(service, await service.factory(...dependencies, abortSignal));
+    }
 
-                const dependencyInstance = this._serviceInstances.get(dependencyDefinition);
-                if (!dependencyInstance) {
-                    throw new Error(`Service '${dependency.toString()}' has not been instantiated in the '${this._friendlyName}' container.`);
-                }
+    /**
+     * Resolves a dependency by contract identity for a consuming service.
+     * Checks local services first, then walks up the parent chain.
+     * Registers the consumer as a dependent in whichever container owns the dependency.
+     * @param contract The contract identity to resolve.
+     * @param consumer The service definition that consumes this dependency.
+     * @returns The resolved service instance.
+     */
+    private _resolveDependency(contract: symbol, consumer: WeaklyTypedServiceDefinition): IService<symbol> & Partial<IDisposable> {
+        const definition = this._serviceDefinitions.get(contract);
+        if (definition) {
+            let dependentDefinitions = this._serviceDependents.get(definition);
+            if (!dependentDefinitions) {
+                this._serviceDependents.set(definition, (dependentDefinitions = new Set()));
+            }
+            dependentDefinitions.add(consumer);
 
-                return dependencyInstance;
-            }) ?? [];
+            const instance = this._serviceInstances.get(definition);
+            if (!instance) {
+                throw new Error(`Service '${contract.toString()}' has not been instantiated in the '${this._friendlyName}' container.`);
+            }
+            return instance;
+        }
 
-        this._serviceInstances.set(service, await service.factory(...dependencies, abortSignal));
+        if (this._parent) {
+            return this._parent._resolveDependency(contract, consumer);
+        }
+
+        throw new Error(`Service '${contract.toString()}' has not been registered in the '${this._friendlyName}' container.`);
+    }
+
+    /**
+     * Removes a consumer from the dependent set for a given contract, checking locally first then the parent chain.
+     * @param contract The contract identity.
+     * @param consumer The service definition to remove as a dependent.
+     */
+    private _removeDependentFromChain(contract: symbol, consumer: WeaklyTypedServiceDefinition): void {
+        const definition = this._serviceDefinitions.get(contract);
+        if (definition) {
+            const dependentDefinitions = this._serviceDependents.get(definition);
+            if (dependentDefinitions) {
+                dependentDefinitions.delete(consumer);
+                if (dependentDefinitions.size === 0) {
+                    this._serviceDependents.delete(definition);
+                }
+            }
+            return;
+        }
+
+        this._parent?._removeDependentFromChain(contract, consumer);
     }
 
     private _removeService(service: WeaklyTypedServiceDefinition) {
@@ -145,7 +189,7 @@ export class ServiceContainer implements IDisposable {
         }
 
         const serviceDependents = this._serviceDependents.get(service);
-        if (serviceDependents) {
+        if (serviceDependents && serviceDependents.size > 0) {
             throw new Error(
                 `Service '${service.friendlyName}' has dependents: ${Array.from(serviceDependents)
                     .map((dependent) => dependent.friendlyName)
@@ -162,28 +206,26 @@ export class ServiceContainer implements IDisposable {
             this._serviceDefinitions.delete(contract);
         });
 
-        service.consumes?.forEach((dependency) => {
-            const dependencyDefinition = this._serviceDefinitions.get(dependency);
-            if (dependencyDefinition) {
-                const dependentDefinitions = this._serviceDependents.get(dependencyDefinition);
-                if (dependentDefinitions) {
-                    dependentDefinitions.delete(service);
-                    if (dependentDefinitions.size === 0) {
-                        this._serviceDependents.delete(dependencyDefinition);
-                    }
-                }
-            }
+        // Remove this service as a dependent from each of its consumed dependencies (local or in parent chain).
+        service.consumes?.forEach((contract) => {
+            this._removeDependentFromChain(contract, service);
         });
     }
 
     /**
      * Disposes the service container and all contained services.
+     * Throws if this container is still a parent of any live child containers.
      */
     public dispose() {
+        if (this._children.size > 0) {
+            throw new Error(`'${this._friendlyName}' container cannot be disposed because it has ${this._children.size} active child container(s).`);
+        }
+
         Array.from(this._serviceInstances.keys()).reverse().forEach(this._removeService.bind(this));
         this._serviceInstances.clear();
         this._serviceDependents.clear();
         this._serviceDefinitions.clear();
+        this._parent?._children.delete(this);
         this._isDisposed = true;
     }
 }
diff --git a/packages/dev/inspector-v2/src/services/cli/cliConnectionStatus.ts b/packages/dev/inspector-v2/src/services/cli/cliConnectionStatus.ts
new file mode 100644
index 000000000000..49693ccadf56
--- /dev/null
+++ b/packages/dev/inspector-v2/src/services/cli/cliConnectionStatus.ts
@@ -0,0 +1,22 @@
+import { type IReadonlyObservable } from "core/index";
+import { type IService } from "../../modularity/serviceDefinition";
+
+/**
+ * The service identity for the CLI connection status.
+ */
+export const CliConnectionStatusIdentity = Symbol("CliConnectionStatus");
+
+/**
+ * Provides the connection status of the Inspector CLI bridge.
+ */
+export interface ICliConnectionStatus extends IService<typeof CliConnectionStatusIdentity> {
+    /**
+     * Whether the bridge WebSocket is currently connected.
+     */
+    readonly isConnected: boolean;
+
+    /**
+     * Observable that fires when the connection status changes.
+     */
+    readonly onConnectionStatusChanged: IReadonlyObservable<boolean>;
+}
diff --git a/packages/dev/inspector-v2/src/services/cli/entityQueryService.ts b/packages/dev/inspector-v2/src/services/cli/entityQueryService.ts
new file mode 100644
index 000000000000..86c7e49c64d4
--- /dev/null
+++ b/packages/dev/inspector-v2/src/services/cli/entityQueryService.ts
@@ -0,0 +1,309 @@
+import {
+    type AbstractMesh,
+    type Animation,
+    type AnimationGroup,
+    type BaseTexture,
+    type Camera,
+    type EffectLayer,
+    type FrameGraph,
+    type Geometry,
+    type IDisposable,
+    type IParticleSystem,
+    type ISpriteManager,
+    type Light,
+    type Material,
+    type MorphTargetManager,
+    type MultiMaterial,
+    type PostProcess,
+    type PostProcessRenderPipeline,
+    type Scene,
+    type Skeleton,
+    type Sound,
+    type TransformNode,
+} from "core/index";
+import { UniqueIdGenerator } from "core/Misc/uniqueIdGenerator";
+import { type ServiceDefinition } from "../../modularity/serviceDefinition";
+import { type ISceneContext, SceneContextIdentity } from "../sceneContext";
+import { type IInspectableCommandRegistry, type InspectableCommandDescriptor, InspectableCommandRegistryIdentity } from "./inspectableCommandRegistry";
+
+const UniqueIdArg = {
+    name: "uniqueId",
+    description: "The uniqueId of the entity to query. Omit to list all entities of this type.",
+    required: false,
+} as const;
+
+const SyntheticUniqueIds = new WeakMap<object, number>();
+
+function GetEntityId(entity: object): number {
+    if ("uniqueId" in entity && typeof entity.uniqueId === "number") {
+        return entity.uniqueId;
+    }
+
+    let id = SyntheticUniqueIds.get(entity);
+    if (!id) {
+        SyntheticUniqueIds.set(entity, (id = UniqueIdGenerator.UniqueId));
+    }
+    return id;
+}
+
+interface IEntitySummary {
+    /** The unique id. */
+    uniqueId: number;
+    /** The entity name, if available. */
+    name?: string;
+    /** The class name from getClassName(), if available. */
+    className?: string;
+    /** The parent's uniqueId, if the entity is hierarchical. */
+    parentId?: number;
+}
+
+interface IEntityCollection<T> {
+    /** The command id. */
+    id: string;
+    /** The command description. */
+    description: string;
+    /** Accessor for the entity array from the scene. */
+    getEntities: (scene: Scene) => T[] | undefined;
+    /** Gets the uniqueId from an entity (uses synthetic ids for entities without a native uniqueId). */
+    getUniqueId: (entity: T) => number;
+    /** Builds a summary for listing. */
+    getSummary: (entity: T) => IEntitySummary;
+    /** Serializes a single entity to a plain object. If absent, querying by id returns the summary. */
+    serialize?: (entity: T) => unknown;
+}
+
+function NodeSummary(entity: { uniqueId: number; name: string; getClassName(): string; parent?: { uniqueId: number } | null }): IEntitySummary {
+    return {
+        uniqueId: entity.uniqueId,
+        name: entity.name,
+        className: entity.getClassName(),
+        parentId: entity.parent?.uniqueId,
+    };
+}
+
+function NamedSummary(entity: { uniqueId: number; name: string; getClassName(): string }): IEntitySummary {
+    return {
+        uniqueId: entity.uniqueId,
+        name: entity.name,
+        className: entity.getClassName(),
+    };
+}
+
+function MinimalSummary(entity: { uniqueId: number; name?: string }): IEntitySummary {
+    return {
+        uniqueId: entity.uniqueId,
+        name: entity.name,
+    };
+}
+
+function MakeQueryCommand<T>(collection: IEntityCollection<T>, sceneContext: ISceneContext): InspectableCommandDescriptor {
+    return {
+        id: collection.id,
+        description: collection.description,
+        args: [UniqueIdArg],
+        executeAsync: async (args) => {
+            const scene = sceneContext.currentScene;
+            if (!scene) {
+                throw new Error("No active scene.");
+            }
+
+            const entities = collection.getEntities(scene);
+            if (!entities) {
+                return JSON.stringify([], null, 2);
+            }
+
+            if (!args.uniqueId) {
+                return JSON.stringify(
+                    entities.map((e) => collection.getSummary(e)),
+                    null,
+                    2
+                );
+            }
+
+            const id = parseInt(args.uniqueId, 10);
+            if (isNaN(id)) {
+                throw new Error("uniqueId must be a number.");
+            }
+
+            const entity = entities.find((e) => collection.getUniqueId(e) === id);
+            if (!entity) {
+                throw new Error(`No ${collection.id.replace("query-", "")} found with uniqueId ${id}.`);
+            }
+
+            return JSON.stringify(collection.serialize ? collection.serialize(entity) : collection.getSummary(entity), null, 2);
+        },
+    };
+}
+
+/**
+ * Service that registers CLI commands for querying scene entities by uniqueId.
+ * When uniqueId is omitted, returns a summary list of all entities of that type.
+ */
+export const EntityQueryServiceDefinition: ServiceDefinition<[], [IInspectableCommandRegistry, ISceneContext]> = {
+    friendlyName: "Entity Query Service",
+    consumes: [InspectableCommandRegistryIdentity, SceneContextIdentity],
+    factory: (commandRegistry, sceneContext) => {
+        const collections = [
+            {
+                id: "query-mesh",
+                description: "List meshes, or query a specific mesh by uniqueId.",
+                getEntities: (scene) => scene.meshes,
+                getUniqueId: (e) => e.uniqueId,
+                getSummary: NodeSummary,
+                serialize: (e) => e.serialize(),
+            } satisfies IEntityCollection<AbstractMesh>,
+            {
+                id: "query-light",
+                description: "List lights, or query a specific light by uniqueId.",
+                getEntities: (scene) => scene.lights,
+                getUniqueId: (e) => e.uniqueId,
+                getSummary: NodeSummary,
+                serialize: (e) => e.serialize(),
+            } satisfies IEntityCollection<Light>,
+            {
+                id: "query-camera",
+                description: "List cameras, or query a specific camera by uniqueId.",
+                getEntities: (scene) => scene.cameras,
+                getUniqueId: (e) => e.uniqueId,
+                getSummary: NodeSummary,
+                serialize: (e) => e.serialize(),
+            } satisfies IEntityCollection<Camera>,
+            {
+                id: "query-transformNode",
+                description: "List transform nodes, or query a specific transform node by uniqueId.",
+                getEntities: (scene) => scene.transformNodes,
+                getUniqueId: (e) => e.uniqueId,
+                getSummary: NodeSummary,
+                serialize: (e) => e.serialize(),
+            } satisfies IEntityCollection<TransformNode>,
+            {
+                id: "query-material",
+                description: "List materials, or query a specific material by uniqueId.",
+                getEntities: (scene) => scene.materials,
+                getUniqueId: (e) => e.uniqueId,
+                getSummary: NamedSummary,
+                serialize: (e) => e.serialize(),
+            } satisfies IEntityCollection<Material>,
+            {
+                id: "query-texture",
+                description: "List textures, or query a specific texture by uniqueId.",
+                getEntities: (scene) => scene.textures,
+                getUniqueId: (e) => e.uniqueId,
+                getSummary: NamedSummary,
+                serialize: (e) => e.serialize(),
+            } satisfies IEntityCollection<BaseTexture>,
+            {
+                id: "query-skeleton",
+                description: "List skeletons, or query a specific skeleton by uniqueId.",
+                getEntities: (scene) => scene.skeletons,
+                getUniqueId: (e) => e.uniqueId,
+                getSummary: NamedSummary,
+                serialize: (e) => e.serialize(),
+            } satisfies IEntityCollection<Skeleton>,
+            {
+                id: "query-geometry",
+                description: "List geometries, or query a specific geometry by uniqueId.",
+                getEntities: (scene) => scene.geometries,
+                getUniqueId: (e) => e.uniqueId,
+                getSummary: MinimalSummary,
+                serialize: (e) => e.serialize(),
+            } satisfies IEntityCollection<Geometry>,
+            {
+                id: "query-animation",
+                description: "List animations, or query a specific animation by uniqueId.",
+                getEntities: (scene) => scene.animations,
+                getUniqueId: (e) => e.uniqueId,
+                getSummary: MinimalSummary,
+                serialize: (e) => e.serialize(),
+            } satisfies IEntityCollection<Animation>,
+            {
+                id: "query-animationGroup",
+                description: "List animation groups, or query a specific animation group by uniqueId.",
+                getEntities: (scene) => scene.animationGroups,
+                getUniqueId: (e) => e.uniqueId,
+                getSummary: NamedSummary,
+                serialize: (e) => e.serialize(),
+            } satisfies IEntityCollection<AnimationGroup>,
+            {
+                id: "query-particleSystem",
+                description: "List particle systems, or query a specific particle system by uniqueId.",
+                getEntities: (scene) => scene.particleSystems,
+                getUniqueId: (e) => e.uniqueId,
+                getSummary: NamedSummary,
+                serialize: (e) => e.serialize(false),
+            } satisfies IEntityCollection<IParticleSystem>,
+            {
+                id: "query-morphTargetManager",
+                description: "List morph target managers, or query a specific morph target manager by uniqueId.",
+                getEntities: (scene) => scene.morphTargetManagers,
+                getUniqueId: (e) => e.uniqueId,
+                getSummary: MinimalSummary,
+                serialize: (e) => e.serialize(),
+            } satisfies IEntityCollection<MorphTargetManager>,
+            {
+                id: "query-multiMaterial",
+                description: "List multi-materials, or query a specific multi-material by uniqueId.",
+                getEntities: (scene) => scene.multiMaterials,
+                getUniqueId: (e) => e.uniqueId,
+                getSummary: NamedSummary,
+                serialize: (e) => e.serialize(),
+            } satisfies IEntityCollection<MultiMaterial>,
+            {
+                id: "query-postProcess",
+                description: "List post-processes, or query a specific post-process by uniqueId.",
+                getEntities: (scene) => scene.postProcesses,
+                getUniqueId: (e) => e.uniqueId,
+                getSummary: NamedSummary,
+                serialize: (e) => e.serialize(),
+            } satisfies IEntityCollection<PostProcess>,
+            {
+                id: "query-frameGraph",
+                description: "List frame graphs, or query a specific frame graph by uniqueId.",
+                getEntities: (scene) => scene.frameGraphs,
+                getUniqueId: (e) => e.uniqueId,
+                getSummary: NamedSummary,
+            } satisfies IEntityCollection<FrameGraph>,
+            {
+                id: "query-effectLayer",
+                description: "List effect layers, or query a specific effect layer by uniqueId.",
+                getEntities: (scene) => scene.effectLayers,
+                getUniqueId: (e) => e.uniqueId,
+                getSummary: NamedSummary,
+                serialize: (e) => e.serialize?.(),
+            } satisfies IEntityCollection<EffectLayer>,
+            {
+                id: "query-spriteManager",
+                description: "List sprite managers, or query a specific sprite manager by uniqueId.",
+                getEntities: (scene) => scene.spriteManagers,
+                getUniqueId: (e) => e.uniqueId,
+                getSummary: MinimalSummary,
+                serialize: (e) => e.serialize(false),
+            } satisfies IEntityCollection<ISpriteManager>,
+            {
+                id: "query-sound",
+                description: "List sounds in the main sound track, or query a specific sound by uniqueId.",
+                getEntities: (scene) => scene.mainSoundTrack?.soundCollection ?? [],
+                getUniqueId: (e) => GetEntityId(e),
+                getSummary: (e) => ({ uniqueId: GetEntityId(e), name: e.name, className: e.getClassName() }),
+                serialize: (e) => e.serialize(),
+            } satisfies IEntityCollection<Sound>,
+            {
+                id: "query-renderingPipeline",
+                description: "List rendering pipelines, or query a specific rendering pipeline by uniqueId.",
+                getEntities: (scene) => scene.postProcessRenderPipelineManager?.supportedPipelines ?? [],
+                getUniqueId: (e) => e.uniqueId,
+                getSummary: NamedSummary,
+            } satisfies IEntityCollection<PostProcessRenderPipeline>,
+        ];
+
+        const registrations: IDisposable[] = collections.map((col) => commandRegistry.addCommand(MakeQueryCommand(col as IEntityCollection<unknown>, sceneContext)));
+
+        return {
+            dispose: () => {
+                for (const reg of registrations) {
+                    reg.dispose();
+                }
+            },
+        };
+    },
+};
diff --git a/packages/dev/inspector-v2/src/services/cli/inspectableBridgeService.ts b/packages/dev/inspector-v2/src/services/cli/inspectableBridgeService.ts
new file mode 100644
index 000000000000..f8f2c5242682
--- /dev/null
+++ b/packages/dev/inspector-v2/src/services/cli/inspectableBridgeService.ts
@@ -0,0 +1,183 @@
+import { type IDisposable } from "core/index";
+import { Observable } from "core/Misc/observable";
+import { type BrowserRequest, type BrowserResponse, type CommandInfo } from "../../cli/protocol";
+import { type ServiceDefinition } from "../../modularity/serviceDefinition";
+import { type ICliConnectionStatus, CliConnectionStatusIdentity } from "./cliConnectionStatus";
+import { type IInspectableCommandRegistry, type InspectableCommandDescriptor, InspectableCommandRegistryIdentity } from "./inspectableCommandRegistry";
+
+import { Logger } from "core/Misc/logger";
+
+/**
+ * Options for the inspectable bridge service.
+ */
+export interface IInspectableBridgeServiceOptions {
+    /**
+     * The WebSocket port for the bridge's browser port.
+     */
+    port: number;
+
+    /**
+     * The session display name sent to the bridge.
+     */
+    name: string;
+}
+
+/**
+ * Creates the service definition for the InspectableBridgeService.
+ * @param options The options for connecting to the bridge.
+ * @returns A service definition that produces an IInspectableCommandRegistry.
+ */
+export function MakeInspectableBridgeServiceDefinition(options: IInspectableBridgeServiceOptions): ServiceDefinition<[IInspectableCommandRegistry, ICliConnectionStatus], []> {
+    return {
+        friendlyName: "Inspectable Bridge Service",
+        produces: [InspectableCommandRegistryIdentity, CliConnectionStatusIdentity],
+        factory: () => {
+            const commands = new Map<string, InspectableCommandDescriptor>();
+            let ws: WebSocket | null = null;
+            let reconnectTimer: ReturnType<typeof setTimeout> | null = null;
+            let disposed = false;
+            let connected = false;
+            const onConnectionStatusChanged = new Observable<boolean>();
+
+            function setConnected(value: boolean) {
+                if (connected !== value) {
+                    connected = value;
+                    onConnectionStatusChanged.notifyObservers(value);
+                }
+            }
+
+            function sendToBridge(message: BrowserRequest) {
+                ws?.send(JSON.stringify(message));
+            }
+
+            function connect() {
+                if (disposed) {
+                    return;
+                }
+
+                try {
+                    ws = new WebSocket(`ws://127.0.0.1:${options.port}`);
+                } catch {
+                    scheduleReconnect();
+                    return;
+                }
+
+                ws.onopen = () => {
+                    setConnected(true);
+                    sendToBridge({ type: "register", name: options.name });
+                };
+
+                ws.onmessage = (event) => {
+                    try {
+                        const message = JSON.parse(event.data as string);
+                        void handleMessage(message);
+                    } catch {
+                        Logger.Warn("InspectableBridgeService: Failed to parse message from bridge.");
+                    }
+                };
+
+                ws.onclose = () => {
+                    ws = null;
+                    setConnected(false);
+                    scheduleReconnect();
+                };
+
+                ws.onerror = () => {
+                    // onclose will fire after onerror, which handles reconnection.
+                };
+            }
+
+            function scheduleReconnect() {
+                if (disposed || reconnectTimer !== null) {
+                    return;
+                }
+                reconnectTimer = setTimeout(() => {
+                    reconnectTimer = null;
+                    connect();
+                }, 3000);
+            }
+
+            async function handleMessage(message: BrowserResponse) {
+                switch (message.type) {
+                    case "listCommands": {
+                        const commandList: CommandInfo[] = Array.from(commands.values()).map((cmd) => ({
+                            id: cmd.id,
+                            description: cmd.description,
+                            args: cmd.args,
+                        }));
+                        sendToBridge({
+                            type: "commandListResponse",
+                            requestId: message.requestId,
+                            commands: commandList,
+                        });
+                        break;
+                    }
+                    case "execCommand": {
+                        const command = commands.get(message.commandId);
+                        if (!command) {
+                            sendToBridge({
+                                type: "commandResponse",
+                                requestId: message.requestId,
+                                error: `Unknown command: ${message.commandId}`,
+                            });
+                            break;
+                        }
+                        try {
+                            const result = await command.executeAsync(message.args);
+                            sendToBridge({
+                                type: "commandResponse",
+                                requestId: message.requestId,
+                                result,
+                            });
+                        } catch (error: unknown) {
+                            sendToBridge({
+                                type: "commandResponse",
+                                requestId: message.requestId,
+                                error: String(error),
+                            });
+                        }
+                        break;
+                    }
+                }
+            }
+
+            // Initiate connection.
+            connect();
+
+            const registry: IInspectableCommandRegistry & ICliConnectionStatus & IDisposable = {
+                addCommand(descriptor: InspectableCommandDescriptor): IDisposable {
+                    if (commands.has(descriptor.id)) {
+                        throw new Error(`Command '${descriptor.id}' is already registered.`);
+                    }
+                    commands.set(descriptor.id, descriptor);
+                    return {
+                        dispose: () => {
+                            commands.delete(descriptor.id);
+                        },
+                    };
+                },
+                get isConnected() {
+                    return connected;
+                },
+                onConnectionStatusChanged,
+                dispose: () => {
+                    disposed = true;
+                    if (reconnectTimer !== null) {
+                        clearTimeout(reconnectTimer);
+                        reconnectTimer = null;
+                    }
+                    commands.clear();
+                    setConnected(false);
+                    onConnectionStatusChanged.clear();
+                    if (ws) {
+                        ws.onclose = null;
+                        ws.close();
+                        ws = null;
+                    }
+                },
+            };
+
+            return registry;
+        },
+    };
+}
diff --git a/packages/dev/inspector-v2/src/services/cli/inspectableCommandRegistry.ts b/packages/dev/inspector-v2/src/services/cli/inspectableCommandRegistry.ts
new file mode 100644
index 000000000000..02afddf7e53a
--- /dev/null
+++ b/packages/dev/inspector-v2/src/services/cli/inspectableCommandRegistry.ts
@@ -0,0 +1,67 @@
+import { type IDisposable } from "core/index";
+import { type IService } from "../../modularity/serviceDefinition";
+
+/**
+ * Describes an argument for an inspectable command.
+ */
+export type InspectableCommandArg = {
+    /**
+     * The name of the argument.
+     */
+    name: string;
+
+    /**
+     * A description of the argument.
+     */
+    description: string;
+
+    /**
+     * Whether the argument is required.
+     */
+    required?: boolean;
+};
+
+/**
+ * Describes a command that can be invoked from the CLI.
+ */
+export type InspectableCommandDescriptor = {
+    /**
+     * A unique identifier for the command.
+     */
+    id: string;
+
+    /**
+     * A human-readable description of what the command does.
+     */
+    description: string;
+
+    /**
+     * The arguments that this command accepts.
+     */
+    args?: InspectableCommandArg[];
+
+    /**
+     * Executes the command with the given arguments and returns a result string.
+     * @param args A map of argument names to their values.
+     * @returns A promise that resolves to the result string.
+     */
+    executeAsync: (args: Record<string, string>) => Promise<string>;
+};
+
+/**
+ * The service identity for the inspectable command registry.
+ */
+export const InspectableCommandRegistryIdentity = Symbol("InspectableCommandRegistry");
+
+/**
+ * A registry for commands that can be invoked from the Inspector CLI.
+ * @experimental
+ */
+export interface IInspectableCommandRegistry extends IService<typeof InspectableCommandRegistryIdentity> {
+    /**
+     * Registers a command that can be invoked from the Inspector CLI.
+     * @param descriptor The command descriptor.
+     * @returns A disposable token that unregisters the command when disposed.
+     */
+    addCommand(descriptor: InspectableCommandDescriptor): IDisposable;
+}
diff --git a/packages/dev/inspector-v2/src/services/cli/perfTraceCommandService.ts b/packages/dev/inspector-v2/src/services/cli/perfTraceCommandService.ts
new file mode 100644
index 000000000000..11f5e8acdabd
--- /dev/null
+++ b/packages/dev/inspector-v2/src/services/cli/perfTraceCommandService.ts
@@ -0,0 +1,85 @@
+import { PerformanceViewerCollector } from "core/Misc/PerformanceViewer/performanceViewerCollector";
+import { DefaultPerfStrategies } from "../../misc/defaultPerfStrategies";
+import { type ServiceDefinition } from "../../modularity/serviceDefinition";
+import { type ISceneContext, SceneContextIdentity } from "../sceneContext";
+import { type IInspectableCommandRegistry, InspectableCommandRegistryIdentity } from "./inspectableCommandRegistry";
+
+import "core/Misc/PerformanceViewer/performanceViewerSceneExtension";
+
+/**
+ * Service that registers CLI commands for performance tracing using the PerformanceViewerCollector.
+ * start-perf-trace begins collecting data, stop-perf-trace stops and returns the collected data as JSON.
+ */
+export const PerfTraceCommandServiceDefinition: ServiceDefinition<[], [IInspectableCommandRegistry, ISceneContext]> = {
+    friendlyName: "Perf Trace Command Service",
+    consumes: [InspectableCommandRegistryIdentity, SceneContextIdentity],
+    factory: (commandRegistry, sceneContext) => {
+        let perfCollector: PerformanceViewerCollector | undefined;
+
+        const startReg = commandRegistry.addCommand({
+            id: "start-perf-trace",
+            description: "Start collecting performance trace data.",
+            executeAsync: async () => {
+                const scene = sceneContext.currentScene;
+                if (!scene) {
+                    throw new Error("No active scene.");
+                }
+
+                if (perfCollector?.isStarted) {
+                    return "Performance trace is already running.";
+                }
+
+                perfCollector = scene.getPerfCollector();
+                perfCollector.stop();
+                perfCollector.clear(false);
+                perfCollector.addCollectionStrategies(...DefaultPerfStrategies);
+                perfCollector.start(true);
+
+                return "Performance trace started.";
+            },
+        });
+
+        const stopReg = commandRegistry.addCommand({
+            id: "stop-perf-trace",
+            description: "Stop collecting performance trace data and return the results as JSON.",
+            executeAsync: async () => {
+                if (!perfCollector || !perfCollector.isStarted) {
+                    throw new Error("Performance trace is not running. Run start-perf-trace first.");
+                }
+
+                perfCollector.stop();
+
+                const datasets = perfCollector.datasets;
+                const ids = datasets.ids;
+                const rawData = datasets.data.subarray(0, datasets.data.itemLength);
+                const sliceSize = ids.length + PerformanceViewerCollector.SliceDataOffset;
+
+                const samples: Record<string, unknown>[] = [];
+                for (let i = 0; i < rawData.length; i += sliceSize) {
+                    const timestamp = rawData[i];
+                    const sample: Record<string, unknown> = { timestamp };
+                    for (let j = 0; j < ids.length; j++) {
+                        sample[ids[j]] = rawData[i + PerformanceViewerCollector.SliceDataOffset + j];
+                    }
+                    samples.push(sample);
+                }
+
+                perfCollector.clear(false);
+                perfCollector = undefined;
+
+                return JSON.stringify({ strategies: ids, sampleCount: samples.length, samples }, null, 2);
+            },
+        });
+
+        return {
+            dispose: () => {
+                startReg.dispose();
+                stopReg.dispose();
+                if (perfCollector?.isStarted) {
+                    perfCollector.stop();
+                }
+                perfCollector = undefined;
+            },
+        };
+    },
+};
diff --git a/packages/dev/inspector-v2/src/services/cli/screenshotCommandService.ts b/packages/dev/inspector-v2/src/services/cli/screenshotCommandService.ts
new file mode 100644
index 000000000000..fd19e0d11279
--- /dev/null
+++ b/packages/dev/inspector-v2/src/services/cli/screenshotCommandService.ts
@@ -0,0 +1,104 @@
+import { FrameGraphUtils } from "core/FrameGraph/frameGraphUtils";
+import { CreateScreenshotUsingRenderTargetAsync } from "core/Misc/screenshotTools";
+import { type ServiceDefinition } from "../../modularity/serviceDefinition";
+import { type ISceneContext, SceneContextIdentity } from "../sceneContext";
+import { type IInspectableCommandRegistry, InspectableCommandRegistryIdentity } from "./inspectableCommandRegistry";
+
+/**
+ * Service that registers a CLI command for capturing a screenshot of the scene.
+ * Returns the image as a base64 data string, suitable for consumption by AI agents.
+ */
+export const ScreenshotCommandServiceDefinition: ServiceDefinition<[], [IInspectableCommandRegistry, ISceneContext]> = {
+    friendlyName: "Screenshot Command Service",
+    consumes: [InspectableCommandRegistryIdentity, SceneContextIdentity],
+    factory: (commandRegistry, sceneContext) => {
+        const registration = commandRegistry.addCommand({
+            id: "take-screenshot",
+            description: "Capture a screenshot of the scene. Returns base64-encoded PNG data.",
+            args: [
+                {
+                    name: "cameraUniqueId",
+                    description: "The uniqueId of the camera to use. Defaults to the active camera.",
+                    required: false,
+                },
+                {
+                    name: "width",
+                    description: "Screenshot width in pixels. When set, uses custom size mode.",
+                    required: false,
+                },
+                {
+                    name: "height",
+                    description: "Screenshot height in pixels. When set, uses custom size mode.",
+                    required: false,
+                },
+                {
+                    name: "precision",
+                    description: "Resolution multiplier (e.g. 2 for double resolution). Defaults to 1.",
+                    required: false,
+                },
+            ],
+            executeAsync: async (args) => {
+                const scene = sceneContext.currentScene;
+                if (!scene) {
+                    throw new Error("No active scene.");
+                }
+
+                const engine = scene.getEngine();
+
+                // Resolve camera: explicit uniqueId, or active/frame-graph camera.
+                let camera;
+                if (args.cameraUniqueId) {
+                    const cameraId = parseInt(args.cameraUniqueId, 10);
+                    if (isNaN(cameraId)) {
+                        throw new Error("cameraUniqueId must be a number.");
+                    }
+                    camera = scene.cameras.find((c) => c.uniqueId === cameraId);
+                    if (!camera) {
+                        throw new Error(`No camera found with uniqueId ${cameraId}.`);
+                    }
+                } else {
+                    camera = scene.frameGraph ? FrameGraphUtils.FindMainCamera(scene.frameGraph) : scene.activeCamera;
+                }
+
+                if (!camera) {
+                    throw new Error("No camera available for screenshot.");
+                }
+
+                const precision = args.precision !== undefined ? Number(args.precision) : 1;
+                if (!Number.isFinite(precision) || precision <= 0) {
+                    throw new Error("precision must be a finite number greater than 0.");
+                }
+
+                let width: number | undefined;
+                if (args.width !== undefined) {
+                    width = Number(args.width);
+                    if (!Number.isFinite(width) || width <= 0 || !Number.isInteger(width)) {
+                        throw new Error("width must be a finite positive integer.");
+                    }
+                }
+
+                let height: number | undefined;
+                if (args.height !== undefined) {
+                    height = Number(args.height);
+                    if (!Number.isFinite(height) || height <= 0 || !Number.isInteger(height)) {
+                        throw new Error("height must be a finite positive integer.");
+                    }
+                }
+                const screenshotSize = width !== undefined && height !== undefined ? { width, height, precision } : { precision };
+
+                // Omit fileName to get data URL back without triggering a download.
+                const dataUrl = await CreateScreenshotUsingRenderTargetAsync(engine, camera, screenshotSize, "image/png");
+
+                // Strip the data URI prefix to return raw base64, which is what AI agent APIs expect.
+                const commaIndex = dataUrl.indexOf(",");
+                return commaIndex !== -1 ? dataUrl.substring(commaIndex + 1) : dataUrl;
+            },
+        });
+
+        return {
+            dispose: () => {
+                registration.dispose();
+            },
+        };
+    },
+};
diff --git a/packages/dev/inspector-v2/src/services/cli/shaderCommandService.ts b/packages/dev/inspector-v2/src/services/cli/shaderCommandService.ts
new file mode 100644
index 000000000000..53190dcabef9
--- /dev/null
+++ b/packages/dev/inspector-v2/src/services/cli/shaderCommandService.ts
@@ -0,0 +1,84 @@
+import { type ServiceDefinition } from "../../modularity/serviceDefinition";
+import { type ISceneContext, SceneContextIdentity } from "../sceneContext";
+import { type IInspectableCommandRegistry, InspectableCommandRegistryIdentity } from "./inspectableCommandRegistry";
+
+/**
+ * Service that registers a CLI command for retrieving compiled shader code from a material.
+ */
+export const ShaderCommandServiceDefinition: ServiceDefinition<[], [IInspectableCommandRegistry, ISceneContext]> = {
+    friendlyName: "Shader Command Service",
+    consumes: [InspectableCommandRegistryIdentity, SceneContextIdentity],
+    factory: (commandRegistry, sceneContext) => {
+        const registration = commandRegistry.addCommand({
+            id: "get-shader-code",
+            description: "Get the shader code for a material by uniqueId.",
+            args: [
+                {
+                    name: "uniqueId",
+                    description: "The uniqueId of the material.",
+                    required: true,
+                },
+                {
+                    name: "variant",
+                    description: "Which shader variant to return: compiled (default), raw, or beforeMigration.",
+                    required: false,
+                },
+            ],
+            executeAsync: async (args) => {
+                const scene = sceneContext.currentScene;
+                if (!scene) {
+                    throw new Error("No active scene.");
+                }
+
+                const id = parseInt(args.uniqueId, 10);
+                if (isNaN(id)) {
+                    throw new Error("uniqueId must be a number.");
+                }
+
+                const material = scene.materials.find((m) => m.uniqueId === id);
+                if (!material) {
+                    throw new Error(`No material found with uniqueId ${id}.`);
+                }
+
+                const effect = material.getEffect();
+                if (!effect) {
+                    throw new Error(`Material "${material.name}" has no effect. It may not have been rendered yet.`);
+                }
+
+                if (!effect.isReady()) {
+                    throw new Error(`Material "${material.name}" effect is not ready. Wait for it to be rendered.`);
+                }
+
+                const variant = args.variant ?? "compiled";
+
+                let vertexShader: string;
+                let fragmentShader: string;
+
+                switch (variant) {
+                    case "compiled":
+                        vertexShader = effect.vertexSourceCode;
+                        fragmentShader = effect.fragmentSourceCode;
+                        break;
+                    case "raw":
+                        vertexShader = effect.rawVertexSourceCode;
+                        fragmentShader = effect.rawFragmentSourceCode;
+                        break;
+                    case "beforeMigration":
+                        vertexShader = effect.vertexSourceCodeBeforeMigration;
+                        fragmentShader = effect.fragmentSourceCodeBeforeMigration;
+                        break;
+                    default:
+                        throw new Error(`Unknown variant "${variant}". Use: compiled, raw, or beforeMigration.`);
+                }
+
+                return JSON.stringify({ vertexShader, fragmentShader }, null, 2);
+            },
+        });
+
+        return {
+            dispose: () => {
+                registration.dispose();
+            },
+        };
+    },
+};
diff --git a/packages/dev/inspector-v2/src/services/cli/statsCommandService.ts b/packages/dev/inspector-v2/src/services/cli/statsCommandService.ts
new file mode 100644
index 000000000000..a5fd73361617
--- /dev/null
+++ b/packages/dev/inspector-v2/src/services/cli/statsCommandService.ts
@@ -0,0 +1,203 @@
+import { EngineInstrumentation } from "core/Instrumentation/engineInstrumentation";
+import { SceneInstrumentation } from "core/Instrumentation/sceneInstrumentation";
+import { type ServiceDefinition } from "../../modularity/serviceDefinition";
+import { type ISceneContext, SceneContextIdentity } from "../sceneContext";
+import { type IInspectableCommandRegistry, InspectableCommandRegistryIdentity } from "./inspectableCommandRegistry";
+
+// Side-effect imports for engine query support (needed by EngineInstrumentation).
+import "core/Engines/AbstractEngine/abstractEngine.timeQuery";
+import "core/Engines/Extensions/engine.query";
+
+/**
+ * Service that registers CLI commands for querying scene and engine statistics.
+ */
+export const StatsCommandServiceDefinition: ServiceDefinition<[], [IInspectableCommandRegistry, ISceneContext]> = {
+    friendlyName: "Stats Command Service",
+    consumes: [InspectableCommandRegistryIdentity, SceneContextIdentity],
+    factory: (commandRegistry, sceneContext) => {
+        let sceneInstrumentation: SceneInstrumentation | undefined;
+        let engineInstrumentation: EngineInstrumentation | undefined;
+
+        function disposeInstrumentation() {
+            sceneInstrumentation?.dispose();
+            sceneInstrumentation = undefined;
+            engineInstrumentation?.dispose();
+            engineInstrumentation = undefined;
+        }
+
+        const startPerfReg = commandRegistry.addCommand({
+            id: "start-perf-instrumentation",
+            description: "Start scene and engine performance instrumentation for frame stats collection.",
+            executeAsync: async () => {
+                const scene = sceneContext.currentScene;
+                if (!scene) {
+                    throw new Error("No active scene.");
+                }
+
+                // Dispose any stale instrumentation (e.g. scene changed).
+                if (sceneInstrumentation && sceneInstrumentation.scene !== scene) {
+                    disposeInstrumentation();
+                }
+
+                if (sceneInstrumentation) {
+                    return "Performance instrumentation is already running.";
+                }
+
+                sceneInstrumentation = new SceneInstrumentation(scene);
+                sceneInstrumentation.captureActiveMeshesEvaluationTime = true;
+                sceneInstrumentation.captureRenderTargetsRenderTime = true;
+                sceneInstrumentation.captureFrameTime = true;
+                sceneInstrumentation.captureRenderTime = true;
+                sceneInstrumentation.captureInterFrameTime = true;
+                sceneInstrumentation.captureParticlesRenderTime = true;
+                sceneInstrumentation.captureSpritesRenderTime = true;
+                sceneInstrumentation.capturePhysicsTime = true;
+                sceneInstrumentation.captureAnimationsTime = true;
+
+                engineInstrumentation = new EngineInstrumentation(scene.getEngine());
+                engineInstrumentation.captureGPUFrameTime = true;
+
+                return "Performance instrumentation started.";
+            },
+        });
+
+        const stopPerfReg = commandRegistry.addCommand({
+            id: "stop-perf-instrumentation",
+            description: "Stop scene and engine performance instrumentation.",
+            executeAsync: async () => {
+                if (!sceneInstrumentation && !engineInstrumentation) {
+                    return "Performance instrumentation is not running.";
+                }
+
+                disposeInstrumentation();
+                return "Performance instrumentation stopped.";
+            },
+        });
+
+        const countStatsReg = commandRegistry.addCommand({
+            id: "get-count-stats",
+            description: "Get scene entity counts (meshes, lights, vertices, draw calls, etc.).",
+            executeAsync: async () => {
+                const scene = sceneContext.currentScene;
+                if (!scene) {
+                    throw new Error("No active scene.");
+                }
+
+                let activeMeshesCount = scene.getActiveMeshes().length;
+                for (const objectRenderer of scene.objectRenderers) {
+                    activeMeshesCount += objectRenderer.getActiveMeshes().length;
+                }
+
+                const activeIndices = scene.getActiveIndices();
+
+                return JSON.stringify(
+                    {
+                        totalMeshes: scene.meshes.length,
+                        activeMeshes: activeMeshesCount,
+                        activeIndices,
+                        activeFaces: Math.floor(activeIndices / 3),
+                        activeBones: scene.getActiveBones(),
+                        activeParticles: scene.getActiveParticles(),
+                        drawCalls: scene.getEngine()._drawCalls.current,
+                        totalLights: scene.lights.length,
+                        totalVertices: scene.getTotalVertices(),
+                        totalMaterials: scene.materials.length,
+                        totalTextures: scene.textures.length,
+                    },
+                    null,
+                    2
+                );
+            },
+        });
+
+        const frameStatsReg = commandRegistry.addCommand({
+            id: "get-frame-stats",
+            description: "Get frame timing statistics. Requires start-perf-instrumentation to be run first.",
+            executeAsync: async () => {
+                if (!sceneInstrumentation || !engineInstrumentation) {
+                    throw new Error("Performance instrumentation is not running. Run start-perf-instrumentation first.");
+                }
+
+                const si = sceneInstrumentation;
+                const ei = engineInstrumentation;
+
+                const round = (v: number) => Math.round(v * 100) / 100;
+
+                return JSON.stringify(
+                    {
+                        absoluteFPS: Math.floor(1000.0 / si.frameTimeCounter.lastSecAverage),
+                        meshesSelectionMs: round(si.activeMeshesEvaluationTimeCounter.lastSecAverage),
+                        renderTargetsMs: round(si.renderTargetsRenderTimeCounter.lastSecAverage),
+                        particlesMs: round(si.particlesRenderTimeCounter.lastSecAverage),
+                        spritesMs: round(si.spritesRenderTimeCounter.lastSecAverage),
+                        animationsMs: round(si.animationsTimeCounter.lastSecAverage),
+                        physicsMs: round(si.physicsTimeCounter.lastSecAverage),
+                        renderMs: round(si.renderTimeCounter.lastSecAverage),
+                        frameMs: round(si.frameTimeCounter.lastSecAverage),
+                        interFrameMs: round(si.interFrameTimeCounter.lastSecAverage),
+                        gpuFrameMs: round(ei.gpuFrameTimeCounter.lastSecAverage * 0.000001),
+                        gpuFrameAverageMs: round(ei.gpuFrameTimeCounter.average * 0.000001),
+                    },
+                    null,
+                    2
+                );
+            },
+        });
+
+        const systemStatsReg = commandRegistry.addCommand({
+            id: "get-system-stats",
+            description: "Get engine capabilities and system information.",
+            executeAsync: async () => {
+                const scene = sceneContext.currentScene;
+                if (!scene) {
+                    throw new Error("No active scene.");
+                }
+
+                const engine = scene.getEngine();
+                const caps = engine.getCaps();
+
+                return JSON.stringify(
+                    {
+                        resolution: `${engine.getRenderWidth()} x ${engine.getRenderHeight()}`,
+                        hardwareScalingLevel: engine.getHardwareScalingLevel(),
+                        engine: engine.description,
+                        driver: engine.extractDriverInfo(),
+                        capabilities: {
+                            stdDerivatives: caps.standardDerivatives,
+                            compressedTextures: caps.s3tc !== undefined,
+                            hardwareInstances: caps.instancedArrays,
+                            textureFloat: caps.textureFloat,
+                            textureHalfFloat: caps.textureHalfFloat,
+                            renderToTextureFloat: caps.textureFloatRender,
+                            renderToTextureHalfFloat: caps.textureHalfFloatRender,
+                            indices32Bit: caps.uintIndices,
+                            fragmentDepth: caps.fragmentDepthSupported,
+                            highPrecisionShaders: caps.highPrecisionShaderSupported,
+                            drawBuffers: caps.drawBuffersExtension,
+                            vertexArrayObject: caps.vertexArrayObject,
+                            timerQuery: caps.timerQuery !== undefined,
+                            stencil: engine.isStencilEnable,
+                            parallelShaderCompilation: caps.parallelShaderCompile != null,
+                            maxTexturesUnits: caps.maxTexturesImageUnits,
+                            maxTexturesSize: caps.maxTextureSize,
+                            maxAnisotropy: caps.maxAnisotropy,
+                        },
+                    },
+                    null,
+                    2
+                );
+            },
+        });
+
+        return {
+            dispose: () => {
+                startPerfReg.dispose();
+                stopPerfReg.dispose();
+                countStatsReg.dispose();
+                frameStatsReg.dispose();
+                systemStatsReg.dispose();
+                disposeInstrumentation();
+            },
+        };
+    },
+};
diff --git a/packages/dev/inspector-v2/src/services/cliConnectionStatusService.tsx b/packages/dev/inspector-v2/src/services/cliConnectionStatusService.tsx
new file mode 100644
index 000000000000..be203e0a1564
--- /dev/null
+++ b/packages/dev/inspector-v2/src/services/cliConnectionStatusService.tsx
@@ -0,0 +1,59 @@
+import { Button, tokens } from "@fluentui/react-components";
+import { PlugConnectedRegular, PlugDisconnectedRegular } from "@fluentui/react-icons";
+import { useEffect, useRef } from "react";
+
+import { useToast } from "shared-ui-components/fluent/primitives/toast";
+import { Tooltip } from "shared-ui-components/fluent/primitives/tooltip";
+import { useObservableState } from "../hooks/observableHooks";
+import { type ServiceDefinition } from "../modularity/serviceDefinition";
+import { type ICliConnectionStatus, CliConnectionStatusIdentity } from "./cli/cliConnectionStatus";
+import { DefaultToolbarItemOrder } from "./defaultToolbarMetadata";
+import { type IShellService, ShellServiceIdentity } from "./shellService";
+
+export const CliConnectionStatusServiceDefinition: ServiceDefinition<[], [IShellService, ICliConnectionStatus]> = {
+    friendlyName: "CLI Connection Status",
+    consumes: [ShellServiceIdentity, CliConnectionStatusIdentity],
+    factory: (shellService, cliConnectionStatus) => {
+        shellService.addToolbarItem({
+            key: "CLI Connection Status",
+            verticalLocation: "bottom",
+            horizontalLocation: "right",
+            teachingMoment: false,
+            order: DefaultToolbarItemOrder.CliStatus,
+            component: () => {
+                const isConnected = useObservableState(() => cliConnectionStatus.isConnected, cliConnectionStatus.onConnectionStatusChanged);
+                const { showToast } = useToast();
+                const isFirstRender = useRef(true);
+
+                useEffect(() => {
+                    if (isFirstRender.current) {
+                        isFirstRender.current = false;
+                        return;
+                    }
+                    if (isConnected) {
+                        showToast("Inspector bridge connected.", { intent: "success" });
+                    } else {
+                        showToast("Inspector bridge disconnected.", { intent: "warning" });
+                    }
+                }, [isConnected, showToast]);
+
+                // Using raw Fluent Button to pass color directly to the icon.
+                return (
+                    <Tooltip content={isConnected ? "Connected to Inspector CLI Bridge" : "Disconnected from Inspector CLI Bridge"}>
+                        <Button
+                            appearance="subtle"
+                            icon={
+                                isConnected ? (
+                                    <PlugConnectedRegular color={tokens.colorPaletteGreenForeground2} />
+                                ) : (
+                                    <PlugDisconnectedRegular color={tokens.colorPaletteRedForeground2} />
+                                )
+                            }
+                            onClick={() => window.open("https://www.npmjs.com/package/@babylonjs/inspector", "_blank")}
+                        />
+                    </Tooltip>
+                );
+            },
+        });
+    },
+};
diff --git a/packages/dev/inspector-v2/src/services/defaultToolbarMetadata.ts b/packages/dev/inspector-v2/src/services/defaultToolbarMetadata.ts
index fd1fd609be47..7265ca96269d 100644
--- a/packages/dev/inspector-v2/src/services/defaultToolbarMetadata.ts
+++ b/packages/dev/inspector-v2/src/services/defaultToolbarMetadata.ts
@@ -2,4 +2,5 @@ export const enum DefaultToolbarItemOrder {
     FrameRate = 300,
     RefreshProperties = 200,
     Feedback = 100,
+    CliStatus = 0,
 }
diff --git a/packages/dev/inspector-v2/test/unit/cli/bridge.test.ts b/packages/dev/inspector-v2/test/unit/cli/bridge.test.ts
new file mode 100644
index 000000000000..80b849f72edb
--- /dev/null
+++ b/packages/dev/inspector-v2/test/unit/cli/bridge.test.ts
@@ -0,0 +1,293 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+import { StartBridge, type IBridgeHandle } from "../../../src/cli/bridge";
+import WebSocket from "ws";
+import {
+    type BrowserResponse,
+    type CommandListResponse,
+    type CommandResponse,
+    type CommandsResponse,
+    type ExecResponse,
+    type SessionsResponse,
+    type StopResponse,
+} from "../../../src/cli/protocol";
+
+function connect(port: number): Promise<WebSocket> {
+    return new Promise((resolve, reject) => {
+        const ws = new WebSocket(`ws://127.0.0.1:${port}`);
+        ws.on("open", () => resolve(ws));
+        ws.on("error", (err) => reject(err));
+    });
+}
+
+function sendAndReceive<T>(ws: WebSocket, message: unknown): Promise<T> {
+    return new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => reject(new Error("sendAndReceive timeout")), 5000);
+        ws.once("message", (data) => {
+            clearTimeout(timeout);
+            resolve(JSON.parse(data.toString()) as T);
+        });
+        ws.send(JSON.stringify(message));
+    });
+}
+
+function waitForMessage<T>(ws: WebSocket): Promise<T> {
+    return new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => reject(new Error("waitForMessage timeout")), 5000);
+        ws.once("message", (data) => {
+            clearTimeout(timeout);
+            resolve(JSON.parse(data.toString()) as T);
+        });
+    });
+}
+
+function close(ws: WebSocket): Promise<void> {
+    return new Promise((resolve) => {
+        if (ws.readyState === WebSocket.CLOSED) {
+            resolve();
+            return;
+        }
+        ws.on("close", () => resolve());
+        ws.close();
+    });
+}
+
+function tick(ms = 50): Promise<void> {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+describe("Inspector Bridge", () => {
+    let bridge: IBridgeHandle;
+
+    beforeEach(async () => {
+        vi.spyOn(console, "log").mockImplementation(() => {});
+        bridge = await StartBridge({ browserPort: 0, cliPort: 0, sessionWaitTimeoutMs: 200 });
+    });
+
+    afterEach(() => {
+        bridge.shutdown();
+        vi.restoreAllMocks();
+    });
+
+    it("assigns real ports when started with port 0", () => {
+        expect(bridge.browserPort).toBeGreaterThan(0);
+        expect(bridge.cliPort).toBeGreaterThan(0);
+        expect(bridge.browserPort).not.toBe(bridge.cliPort);
+    });
+
+    it("registers a browser session and lists it via CLI", async () => {
+        const browser = await connect(bridge.browserPort);
+        browser.send(JSON.stringify({ type: "register", name: "Test Scene" }));
+        await tick();
+
+        const cli = await connect(bridge.cliPort);
+        const response = await sendAndReceive<SessionsResponse>(cli, { type: "sessions" });
+
+        expect(response.type).toBe("sessionsResponse");
+        expect(response.sessions).toHaveLength(1);
+        expect(response.sessions[0].name).toBe("Test Scene");
+        expect(response.sessions[0].id).toBeGreaterThan(0);
+
+        await close(browser);
+        await close(cli);
+    });
+
+    it("returns empty session list when no browser is connected", async () => {
+        const cli = await connect(bridge.cliPort);
+
+        // WaitForSession has a default 5s timeout. We need it to time out.
+        // Use a short timeout by sending sessions request and waiting.
+        const responsePromise = sendAndReceive<SessionsResponse>(cli, { type: "sessions" });
+
+        // Wait for the bridge's WaitForSession to time out (default 5s).
+        // This test may take up to 5s.
+        const response = await responsePromise;
+
+        expect(response.type).toBe("sessionsResponse");
+        expect(response.sessions).toHaveLength(0);
+
+        await close(cli);
+    });
+
+    it("removes session when browser disconnects", async () => {
+        const browser = await connect(bridge.browserPort);
+        browser.send(JSON.stringify({ type: "register", name: "Temporary Scene" }));
+        await tick();
+
+        // Verify session exists.
+        const cli1 = await connect(bridge.cliPort);
+        const before = await sendAndReceive<SessionsResponse>(cli1, { type: "sessions" });
+        expect(before.sessions).toHaveLength(1);
+        await close(cli1);
+
+        // Disconnect browser.
+        await close(browser);
+        await tick();
+
+        // Verify session is gone (will wait for WaitForSession timeout).
+        const cli2 = await connect(bridge.cliPort);
+        const after = await sendAndReceive<SessionsResponse>(cli2, { type: "sessions" });
+        expect(after.sessions).toHaveLength(0);
+        await close(cli2);
+    });
+
+    it("forwards command listing from browser to CLI", async () => {
+        const browser = await connect(bridge.browserPort);
+        browser.send(JSON.stringify({ type: "register", name: "Scene" }));
+        await tick();
+
+        // Get session id.
+        const cli = await connect(bridge.cliPort);
+        const sessions = await sendAndReceive<SessionsResponse>(cli, { type: "sessions" });
+        const sessionId = sessions.sessions[0].id;
+
+        // CLI requests commands — bridge forwards to browser.
+        const cliResponsePromise = sendAndReceive<CommandsResponse>(cli, { type: "commands", sessionId });
+
+        // Browser receives listCommands request and responds.
+        const browserReq = await waitForMessage<BrowserResponse>(browser);
+        expect(browserReq.type).toBe("listCommands");
+        expect("requestId" in browserReq).toBe(true);
+
+        const commandList: CommandListResponse = {
+            type: "commandListResponse",
+            requestId: (browserReq as { requestId: string }).requestId,
+            commands: [{ id: "take-screenshot", description: "Takes a screenshot" }],
+        };
+        browser.send(JSON.stringify(commandList));
+
+        const cliResponse = await cliResponsePromise;
+        expect(cliResponse.type).toBe("commandListResponse");
+        expect(cliResponse.commands).toHaveLength(1);
+        expect(cliResponse.commands![0].id).toBe("take-screenshot");
+
+        await close(browser);
+        await close(cli);
+    });
+
+    it("forwards command execution from CLI to browser", async () => {
+        const browser = await connect(bridge.browserPort);
+        browser.send(JSON.stringify({ type: "register", name: "Scene" }));
+        await tick();
+
+        const cli = await connect(bridge.cliPort);
+        const sessions = await sendAndReceive<SessionsResponse>(cli, { type: "sessions" });
+        const sessionId = sessions.sessions[0].id;
+
+        // CLI executes a command.
+        const cliResponsePromise = sendAndReceive<ExecResponse>(cli, {
+            type: "exec",
+            sessionId,
+            commandId: "query-mesh",
+            args: { uniqueId: "42" },
+        });
+
+        // Browser receives execCommand and responds.
+        const browserReq = await waitForMessage<BrowserResponse>(browser);
+        expect(browserReq.type).toBe("execCommand");
+
+        const commandResult: CommandResponse = {
+            type: "commandResponse",
+            requestId: (browserReq as { requestId: string }).requestId,
+            result: '{"name":"box","position":[0,0,0]}',
+        };
+        browser.send(JSON.stringify(commandResult));
+
+        const cliResponse = await cliResponsePromise;
+        expect(cliResponse.type).toBe("commandResponse");
+        expect(cliResponse.result).toBe('{"name":"box","position":[0,0,0]}');
+
+        await close(browser);
+        await close(cli);
+    });
+
+    it("returns error for commands on invalid session", async () => {
+        const cli = await connect(bridge.cliPort);
+        const response = await sendAndReceive<CommandsResponse>(cli, { type: "commands", sessionId: 999 });
+
+        expect(response.type).toBe("commandsResponse");
+        expect(response.error).toContain("999");
+
+        await close(cli);
+    });
+
+    it("returns error for exec on invalid session", async () => {
+        const cli = await connect(bridge.cliPort);
+        const response = await sendAndReceive<ExecResponse>(cli, {
+            type: "exec",
+            sessionId: 999,
+            commandId: "test",
+            args: {},
+        });
+
+        expect(response.type).toBe("execResponse");
+        expect(response.error).toContain("999");
+
+        await close(cli);
+    });
+
+    it("handles stop request", async () => {
+        const cli = await connect(bridge.cliPort);
+        const response = await sendAndReceive<StopResponse>(cli, { type: "stop" });
+
+        expect(response.type).toBe("stopResponse");
+        expect(response.success).toBe(true);
+
+        await close(cli);
+    });
+
+    it("supports multiple browser sessions", async () => {
+        const browser1 = await connect(bridge.browserPort);
+        browser1.send(JSON.stringify({ type: "register", name: "Scene A" }));
+        await tick();
+
+        const browser2 = await connect(bridge.browserPort);
+        browser2.send(JSON.stringify({ type: "register", name: "Scene B" }));
+        await tick();
+
+        const cli = await connect(bridge.cliPort);
+        const response = await sendAndReceive<SessionsResponse>(cli, { type: "sessions" });
+
+        expect(response.sessions).toHaveLength(2);
+        const names = response.sessions.map((s) => s.name).sort();
+        expect(names).toEqual(["Scene A", "Scene B"]);
+
+        await close(browser1);
+        await close(browser2);
+        await close(cli);
+    });
+
+    it("ignores malformed JSON on browser port", async () => {
+        const browser = await connect(bridge.browserPort);
+        browser.send("not valid json{{{");
+        await tick();
+
+        // Bridge should still be functional.
+        browser.send(JSON.stringify({ type: "register", name: "After Bad JSON" }));
+        await tick();
+
+        const cli = await connect(bridge.cliPort);
+        const response = await sendAndReceive<SessionsResponse>(cli, { type: "sessions" });
+        expect(response.sessions).toHaveLength(1);
+        expect(response.sessions[0].name).toBe("After Bad JSON");
+
+        await close(browser);
+        await close(cli);
+    });
+
+    it("ignores malformed JSON on CLI port", async () => {
+        const cli = await connect(bridge.cliPort);
+        cli.send("not valid json{{{");
+        await tick();
+
+        // Bridge should still be functional — send a valid request.
+        const browser = await connect(bridge.browserPort);
+        browser.send(JSON.stringify({ type: "register", name: "Scene" }));
+        await tick();
+
+        const response = await sendAndReceive<SessionsResponse>(cli, { type: "sessions" });
+        expect(response.sessions).toHaveLength(1);
+
+        await close(browser);
+        await close(cli);
+    });
+});
diff --git a/packages/dev/inspector-v2/test/unit/cli/cli.test.ts b/packages/dev/inspector-v2/test/unit/cli/cli.test.ts
new file mode 100644
index 000000000000..b1f37b46cf1d
--- /dev/null
+++ b/packages/dev/inspector-v2/test/unit/cli/cli.test.ts
@@ -0,0 +1,361 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { ParseCliArgs, ParseCommandArgs, PrintCommandHelp, ResolveSessionId, SendAndReceive, ValidateSessionId } from "../../../src/cli/cli";
+import { type CommandArgInfo, type CommandInfo, type SessionInfo, type SessionsResponse } from "../../../src/cli/protocol";
+import { EventEmitter } from "events";
+
+// ---------------------------------------------------------------------------
+// ParseCliArgs
+// ---------------------------------------------------------------------------
+
+describe("ParseCliArgs", () => {
+    it("returns defaults when no arguments are given", () => {
+        const args = ParseCliArgs([]);
+        expect(args.help).toBe(false);
+        expect(args.session).toBe(false);
+        expect(args.sessionId).toBeUndefined();
+        expect(args.stop).toBe(false);
+        expect(args.command).toBe(false);
+        expect(args.bridgeScript).toBeUndefined();
+        expect(args.rest).toEqual([]);
+    });
+
+    it("parses --help", () => {
+        const args = ParseCliArgs(["--help"]);
+        expect(args.help).toBe(true);
+    });
+
+    it("parses --stop", () => {
+        const args = ParseCliArgs(["--stop"]);
+        expect(args.stop).toBe(true);
+    });
+
+    it("parses --session without an id", () => {
+        const args = ParseCliArgs(["--session"]);
+        expect(args.session).toBe(true);
+        expect(args.sessionId).toBeUndefined();
+    });
+
+    it("parses --session with a numeric id", () => {
+        const args = ParseCliArgs(["--session", "3"]);
+        expect(args.session).toBe(true);
+        expect(args.sessionId).toBe("3");
+    });
+
+    it("does not treat a non-numeric token after --session as the session id", () => {
+        const args = ParseCliArgs(["--session", "abc"]);
+        expect(args.session).toBe(true);
+        expect(args.sessionId).toBeUndefined();
+        expect(args.rest).toContain("abc");
+    });
+
+    it("parses --command alone", () => {
+        const args = ParseCliArgs(["--command"]);
+        expect(args.command).toBe(true);
+        expect(args.rest).toEqual([]);
+    });
+
+    it("parses --command with a command id as a positional", () => {
+        const args = ParseCliArgs(["--command", "query-mesh"]);
+        expect(args.command).toBe(true);
+        expect(args.rest).toEqual(["query-mesh"]);
+    });
+
+    it("parses --bridge-script value", () => {
+        const args = ParseCliArgs(["--bridge-script", "/path/to/bridge.js"]);
+        expect(args.bridgeScript).toBe("/path/to/bridge.js");
+    });
+
+    it("collects unknown --options into rest", () => {
+        const args = ParseCliArgs(["--command", "query-mesh", "--uniqueId", "42"]);
+        expect(args.command).toBe(true);
+        expect(args.rest).toEqual(["query-mesh", "--uniqueId", "42"]);
+    });
+
+    it("collects unknown boolean-style options (no value) into rest", () => {
+        const args = ParseCliArgs(["--command", "my-cmd", "--verbose"]);
+        expect(args.rest).toEqual(["my-cmd", "--verbose"]);
+    });
+
+    it("handles combined --session <id> --command <cmd> --arg <val>", () => {
+        const args = ParseCliArgs(["--session", "2", "--command", "query-mesh", "--uniqueId", "42"]);
+        expect(args.session).toBe(true);
+        expect(args.sessionId).toBe("2");
+        expect(args.command).toBe(true);
+        expect(args.rest).toEqual(["query-mesh", "--uniqueId", "42"]);
+    });
+
+    it("handles --help with --command (help for a specific command)", () => {
+        const args = ParseCliArgs(["--command", "query-mesh", "--help"]);
+        expect(args.help).toBe(true);
+        expect(args.command).toBe(true);
+        expect(args.rest).toEqual(["query-mesh"]);
+    });
+});
+
+// ---------------------------------------------------------------------------
+// ParseCommandArgs
+// ---------------------------------------------------------------------------
+
+describe("ParseCommandArgs", () => {
+    it("returns empty args when rest has only the command id", () => {
+        const { args, wantsHelp } = ParseCommandArgs(["query-mesh"], false);
+        expect(args).toEqual({});
+        expect(wantsHelp).toBe(false);
+    });
+
+    it("parses key-value pairs from rest", () => {
+        const { args } = ParseCommandArgs(["query-mesh", "--uniqueId", "42", "--name", "box"], false);
+        expect(args).toEqual({ uniqueId: "42", name: "box" });
+    });
+
+    it("detects --help in the arguments", () => {
+        const { wantsHelp } = ParseCommandArgs(["query-mesh", "--help"], false);
+        expect(wantsHelp).toBe(true);
+    });
+
+    it("inherits globalHelp when set to true", () => {
+        const { wantsHelp } = ParseCommandArgs(["query-mesh"], true);
+        expect(wantsHelp).toBe(true);
+    });
+
+    it("ignores a trailing --key without a value", () => {
+        const { args } = ParseCommandArgs(["cmd", "--orphan"], false);
+        expect(args).toEqual({});
+    });
+
+    it("handles mixed --help and key-value args", () => {
+        const { args, wantsHelp } = ParseCommandArgs(["cmd", "--help", "--key", "val"], false);
+        expect(wantsHelp).toBe(true);
+        expect(args).toEqual({ key: "val" });
+    });
+});
+
+// ---------------------------------------------------------------------------
+// PrintCommandHelp
+// ---------------------------------------------------------------------------
+
+describe("PrintCommandHelp", () => {
+    let logSpy: ReturnType<typeof vi.spyOn>;
+    let errorSpy: ReturnType<typeof vi.spyOn>;
+    let originalExitCode: number | undefined;
+
+    beforeEach(() => {
+        logSpy = vi.spyOn(console, "log").mockImplementation(() => {});
+        errorSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+        originalExitCode = process.exitCode as number | undefined;
+        process.exitCode = undefined;
+    });
+
+    afterEach(() => {
+        logSpy.mockRestore();
+        errorSpy.mockRestore();
+        process.exitCode = originalExitCode;
+    });
+
+    it("prints the command description", () => {
+        const descriptor: CommandInfo = { id: "test-cmd", description: "Does a thing" };
+        PrintCommandHelp("test-cmd", descriptor, [], true);
+        expect(logSpy).toHaveBeenCalledWith(expect.stringContaining("Does a thing"));
+    });
+
+    it("prints argument list when args are present", () => {
+        const descriptor: CommandInfo = {
+            id: "test-cmd",
+            description: "Does a thing",
+            args: [
+                { name: "foo", description: "The foo param", required: true },
+                { name: "bar", description: "The bar param" },
+            ],
+        };
+        PrintCommandHelp("test-cmd", descriptor, [], true);
+        const allOutput = logSpy.mock.calls.map((c: unknown[]) => c.join(" ")).join("\n");
+        expect(allOutput).toContain("--foo");
+        expect(allOutput).toContain("(required)");
+        expect(allOutput).toContain("--bar");
+    });
+
+    it("prints missing required args as an error and sets exitCode", () => {
+        const missing: CommandArgInfo[] = [{ name: "uniqueId", description: "entity id", required: true }];
+        const descriptor: CommandInfo = {
+            id: "test-cmd",
+            description: "Does a thing",
+            args: [{ name: "uniqueId", description: "entity id", required: true }],
+        };
+        PrintCommandHelp("test-cmd", descriptor, missing, false);
+        expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining("--uniqueId"));
+        expect(process.exitCode).toBe(1);
+    });
+
+    it("does not set exitCode when help is explicitly requested", () => {
+        const missing: CommandArgInfo[] = [{ name: "uniqueId", description: "entity id", required: true }];
+        const descriptor: CommandInfo = {
+            id: "test-cmd",
+            description: "Does a thing",
+            args: [{ name: "uniqueId", description: "entity id", required: true }],
+        };
+        PrintCommandHelp("test-cmd", descriptor, missing, true);
+        expect(errorSpy).not.toHaveBeenCalled();
+        expect(process.exitCode).toBeUndefined();
+    });
+});
+
+// ---------------------------------------------------------------------------
+// ValidateSessionId
+// ---------------------------------------------------------------------------
+
+describe("ValidateSessionId", () => {
+    const sessions: SessionInfo[] = [
+        { id: 1, name: "Scene A", connectedAt: new Date().toISOString() },
+        { id: 3, name: "Scene B", connectedAt: new Date().toISOString() },
+    ];
+
+    it("returns the matching session when id exists", () => {
+        const match = ValidateSessionId("1", sessions);
+        expect(match.id).toBe(1);
+        expect(match.name).toBe("Scene A");
+    });
+
+    it("throws for a non-numeric id", () => {
+        expect(() => ValidateSessionId("abc", sessions)).toThrow("Session id must be a number.");
+    });
+
+    it("throws when id does not exist and lists active sessions", () => {
+        expect(() => ValidateSessionId("2", sessions)).toThrow(/Session 2 does not exist.*Scene A.*Scene B/s);
+    });
+
+    it("throws when id does not exist and no sessions are active", () => {
+        expect(() => ValidateSessionId("2", [])).toThrow(/Session 2 does not exist.*No active sessions/);
+    });
+});
+
+// ---------------------------------------------------------------------------
+// ResolveSessionId
+// ---------------------------------------------------------------------------
+
+describe("ResolveSessionId", () => {
+    function makeMockSocket(response: unknown): { on: ReturnType<typeof vi.fn>; once: ReturnType<typeof vi.fn>; send: ReturnType<typeof vi.fn> } {
+        const mock = {
+            on: vi.fn(),
+            once: vi.fn(),
+            send: vi.fn(),
+        };
+        mock.once.mockImplementation((_event: string, cb: (data: string) => void) => {
+            queueMicrotask(() => cb(JSON.stringify(response)));
+        });
+        return mock;
+    }
+
+    it("returns the parsed id when an explicit numeric id matches an active session", async () => {
+        const response: SessionsResponse = {
+            type: "sessionsResponse",
+            sessions: [{ id: 5, name: "My Scene", connectedAt: new Date().toISOString() }],
+        };
+        const socket = makeMockSocket(response);
+        const id = await ResolveSessionId(socket as never, "5");
+        expect(id).toBe(5);
+    });
+
+    it("throws for a non-numeric explicit id", async () => {
+        const response: SessionsResponse = { type: "sessionsResponse", sessions: [] };
+        const socket = makeMockSocket(response);
+        await expect(ResolveSessionId(socket as never, "abc")).rejects.toThrow("Session id must be a number.");
+    });
+
+    it("throws when explicit session id does not exist and lists active sessions", async () => {
+        const response: SessionsResponse = {
+            type: "sessionsResponse",
+            sessions: [
+                { id: 1, name: "Scene A", connectedAt: new Date().toISOString() },
+                { id: 3, name: "Scene B", connectedAt: new Date().toISOString() },
+            ],
+        };
+        const socket = makeMockSocket(response);
+        await expect(ResolveSessionId(socket as never, "2")).rejects.toThrow(/Session 2 does not exist.*Scene A.*Scene B/s);
+    });
+
+    it("throws when explicit session id does not exist and no sessions are active", async () => {
+        const response: SessionsResponse = { type: "sessionsResponse", sessions: [] };
+        const socket = makeMockSocket(response);
+        await expect(ResolveSessionId(socket as never, "2")).rejects.toThrow(/Session 2 does not exist.*No active sessions/);
+    });
+
+    it("auto-resolves when exactly one session is active", async () => {
+        const response: SessionsResponse = {
+            type: "sessionsResponse",
+            sessions: [{ id: 7, name: "My Scene", connectedAt: new Date().toISOString() }],
+        };
+        const socket = makeMockSocket(response);
+        const id = await ResolveSessionId(socket as never);
+        expect(id).toBe(7);
+    });
+
+    it("throws when no sessions are active", async () => {
+        const response: SessionsResponse = { type: "sessionsResponse", sessions: [] };
+        const socket = makeMockSocket(response);
+        await expect(ResolveSessionId(socket as never)).rejects.toThrow("No active sessions");
+    });
+
+    it("throws when multiple sessions are active", async () => {
+        const response: SessionsResponse = {
+            type: "sessionsResponse",
+            sessions: [
+                { id: 1, name: "Scene A", connectedAt: new Date().toISOString() },
+                { id: 2, name: "Scene B", connectedAt: new Date().toISOString() },
+            ],
+        };
+        const socket = makeMockSocket(response);
+        await expect(ResolveSessionId(socket as never)).rejects.toThrow("Multiple active sessions");
+    });
+});
+
+// ---------------------------------------------------------------------------
+// SendAndReceive
+// ---------------------------------------------------------------------------
+
+describe("SendAndReceive", () => {
+    function makeMockSocket() {
+        const emitter = new EventEmitter();
+        return {
+            on: emitter.on.bind(emitter),
+            once: emitter.once.bind(emitter),
+            send: vi.fn(() => {
+                // Simulate async response
+            }),
+            _emitter: emitter,
+        };
+    }
+
+    it("sends a JSON message and resolves with the parsed response", async () => {
+        const socket = makeMockSocket();
+        const responsePayload = { type: "sessionsResponse", sessions: [] };
+
+        const promise = SendAndReceive(socket as never, { type: "sessions" });
+
+        // Simulate bridge responding
+        socket._emitter.emit("message", JSON.stringify(responsePayload));
+
+        const result = await promise;
+        expect(result).toEqual(responsePayload);
+        expect(socket.send).toHaveBeenCalledWith(JSON.stringify({ type: "sessions" }));
+    });
+
+    it("rejects on timeout", async () => {
+        vi.useFakeTimers();
+        const socket = makeMockSocket();
+
+        const promise = SendAndReceive(socket as never, { type: "sessions" });
+        vi.advanceTimersByTime(15001);
+
+        await expect(promise).rejects.toThrow("Timeout");
+        vi.useRealTimers();
+    });
+
+    it("rejects when the response is not valid JSON", async () => {
+        const socket = makeMockSocket();
+
+        const promise = SendAndReceive(socket as never, { type: "sessions" });
+        socket._emitter.emit("message", "not json{{{");
+
+        await expect(promise).rejects.toThrow("Failed to parse");
+    });
+});
diff --git a/packages/dev/inspector-v2/test/unit/cli/config.test.ts b/packages/dev/inspector-v2/test/unit/cli/config.test.ts
new file mode 100644
index 000000000000..d920cf079fb6
--- /dev/null
+++ b/packages/dev/inspector-v2/test/unit/cli/config.test.ts
@@ -0,0 +1,61 @@
+import { mkdirSync, rmSync, writeFileSync } from "fs";
+import { join } from "path";
+import { tmpdir } from "os";
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { LoadConfig } from "../../../src/cli/config";
+
+describe("Config Loader", () => {
+    let tempDir: string;
+
+    beforeEach(() => {
+        tempDir = join(tmpdir(), `inspector-config-test-${Date.now()}`);
+        mkdirSync(tempDir, { recursive: true });
+    });
+
+    afterEach(() => {
+        rmSync(tempDir, { recursive: true, force: true });
+    });
+
+    it("returns defaults when no config file exists", () => {
+        const config = LoadConfig(tempDir);
+        expect(config.browserPort).toBe(4400);
+        expect(config.cliPort).toBe(4401);
+    });
+
+    it("reads config from .babyloninspector in the given directory", () => {
+        writeFileSync(join(tempDir, ".babyloninspector"), JSON.stringify({ browserPort: 5500, cliPort: 5501 }));
+        const config = LoadConfig(tempDir);
+        expect(config.browserPort).toBe(5500);
+        expect(config.cliPort).toBe(5501);
+    });
+
+    it("walks up parent directories to find config", () => {
+        const childDir = join(tempDir, "a", "b", "c");
+        mkdirSync(childDir, { recursive: true });
+        writeFileSync(join(tempDir, ".babyloninspector"), JSON.stringify({ browserPort: 6600 }));
+        const config = LoadConfig(childDir);
+        expect(config.browserPort).toBe(6600);
+        expect(config.cliPort).toBe(4401); // default
+    });
+
+    it("merges partial config with defaults", () => {
+        writeFileSync(join(tempDir, ".babyloninspector"), JSON.stringify({ cliPort: 9999 }));
+        const config = LoadConfig(tempDir);
+        expect(config.browserPort).toBe(4400); // default
+        expect(config.cliPort).toBe(9999);
+    });
+
+    it("returns defaults for malformed JSON", () => {
+        writeFileSync(join(tempDir, ".babyloninspector"), "not valid json{{{");
+        const config = LoadConfig(tempDir);
+        expect(config.browserPort).toBe(4400);
+        expect(config.cliPort).toBe(4401);
+    });
+
+    it("ignores non-numeric port values", () => {
+        writeFileSync(join(tempDir, ".babyloninspector"), JSON.stringify({ browserPort: "abc", cliPort: true }));
+        const config = LoadConfig(tempDir);
+        expect(config.browserPort).toBe(4400);
+        expect(config.cliPort).toBe(4401);
+    });
+});
diff --git a/packages/dev/inspector-v2/test/unit/inspectable.test.ts b/packages/dev/inspector-v2/test/unit/inspectable.test.ts
new file mode 100644
index 000000000000..e8565e6ae691
--- /dev/null
+++ b/packages/dev/inspector-v2/test/unit/inspectable.test.ts
@@ -0,0 +1,138 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { NullEngine } from "core/Engines/nullEngine";
+import { Scene } from "core/scene";
+import { StartInspectable, _StartInspectable } from "../../src/inspectable";
+import { type WeaklyTypedServiceDefinition } from "../../src/modularity/serviceContainer";
+
+const TestServiceIdentity = Symbol("TestService");
+const TestService2Identity = Symbol("TestService2");
+
+describe("StartInspectable", () => {
+    let engine: NullEngine;
+    let scene: Scene;
+
+    beforeEach(() => {
+        engine = new NullEngine();
+        scene = new Scene(engine);
+    });
+
+    afterEach(() => {
+        scene.dispose();
+        engine.dispose();
+    });
+
+    it("returns a non-disposed token", () => {
+        const token = StartInspectable(scene);
+        expect(token.isDisposed).toBe(false);
+        token.dispose();
+    });
+
+    it("returns the same container for the same scene", () => {
+        const token1 = _StartInspectable(scene);
+        const token2 = _StartInspectable(scene);
+        expect(token1.serviceContainer).toBe(token2.serviceContainer);
+        token1.dispose();
+        token2.dispose();
+    });
+
+    it("container survives first dispose when ref count > 0", () => {
+        const token1 = _StartInspectable(scene);
+        const token2 = _StartInspectable(scene);
+        const container = token1.serviceContainer;
+
+        token1.dispose();
+        expect(token1.isDisposed).toBe(true);
+
+        const token3 = _StartInspectable(scene);
+        expect(token3.serviceContainer).toBe(container);
+
+        token2.dispose();
+        token3.dispose();
+    });
+
+    it("container is disposed when all tokens are disposed", () => {
+        const token1 = _StartInspectable(scene);
+        const token2 = _StartInspectable(scene);
+
+        token1.dispose();
+        token2.dispose();
+
+        const token3 = _StartInspectable(scene);
+        expect(token3.isDisposed).toBe(false);
+        token3.dispose();
+    });
+
+    it("extra serviceDefinitions are added to the container", async () => {
+        let serviceCreated = false;
+        const extraService: WeaklyTypedServiceDefinition = {
+            friendlyName: "Extra Test Service",
+            produces: [TestServiceIdentity],
+            factory: () => {
+                serviceCreated = true;
+            },
+        };
+
+        const token = StartInspectable(scene, { serviceDefinitions: [extraService] });
+
+        await new Promise((resolve) => setTimeout(resolve, 200));
+        expect(serviceCreated).toBe(true);
+
+        token.dispose();
+    });
+
+    it("extra services are disposed when the token is disposed, before container teardown", async () => {
+        let serviceDisposed = false;
+        const extraService: WeaklyTypedServiceDefinition = {
+            friendlyName: "Disposable Extra Service",
+            produces: [TestServiceIdentity],
+            factory: () => ({
+                testValue: "disposable",
+                dispose: () => {
+                    serviceDisposed = true;
+                },
+            }),
+        };
+
+        const token1 = StartInspectable(scene, { serviceDefinitions: [extraService] });
+        const token2 = StartInspectable(scene);
+
+        await new Promise((resolve) => setTimeout(resolve, 200));
+
+        token1.dispose();
+        expect(serviceDisposed).toBe(true);
+
+        token2.dispose();
+    });
+
+    it("multiple callers can add different extra services", async () => {
+        let service1Created = false;
+        let service2Created = false;
+
+        const extra1: WeaklyTypedServiceDefinition = {
+            friendlyName: "Extra Service 1",
+            produces: [TestServiceIdentity],
+            factory: () => {
+                service1Created = true;
+            },
+        };
+
+        const extra2: WeaklyTypedServiceDefinition = {
+            friendlyName: "Extra Service 2",
+            produces: [TestService2Identity],
+            factory: () => {
+                service2Created = true;
+            },
+        };
+
+        const token1 = StartInspectable(scene, { serviceDefinitions: [extra1] });
+        const token2 = StartInspectable(scene, { serviceDefinitions: [extra2] });
+
+        await new Promise((resolve) => setTimeout(resolve, 200));
+
+        expect(service1Created).toBe(true);
+        expect(service2Created).toBe(true);
+
+        token1.dispose();
+        token2.dispose();
+    });
+});
diff --git a/packages/dev/inspector-v2/test/unit/modularity/serviceContainer.test.ts b/packages/dev/inspector-v2/test/unit/modularity/serviceContainer.test.ts
new file mode 100644
index 000000000000..06b7736d784e
--- /dev/null
+++ b/packages/dev/inspector-v2/test/unit/modularity/serviceContainer.test.ts
@@ -0,0 +1,644 @@
+import { describe, it, expect, vi } from "vitest";
+import { ServiceContainer } from "../../../src/modularity/serviceContainer";
+import { type ServiceDefinition, type IService } from "../../../src/modularity/serviceDefinition";
+import { type IDisposable } from "core/scene";
+
+// ---------------------------------------------------------------------------
+// Helpers — contract symbols and typed service definitions
+// ---------------------------------------------------------------------------
+
+const ContractA = Symbol("ContractA");
+type ContractAId = typeof ContractA;
+
+interface IContractA extends IService<ContractAId> {
+    value: string;
+}
+
+const ContractB = Symbol("ContractB");
+type ContractBId = typeof ContractB;
+
+interface IContractB extends IService<ContractBId> {
+    value: string;
+}
+
+function contractA(value: string, extra?: Partial<IDisposable>): IContractA & Partial<IDisposable> {
+    return { value, ...extra };
+}
+
+function contractAB(value: string, extra?: Partial<IDisposable>): IContractA & IContractB & Partial<IDisposable> {
+    return { value, ...extra };
+}
+
+// ---------------------------------------------------------------------------
+// Basic lifecycle
+// ---------------------------------------------------------------------------
+
+describe("ServiceContainer", () => {
+    describe("basic lifecycle", () => {
+        it("can be created with a friendly name", () => {
+            const container = new ServiceContainer("test");
+            expect(container).toBeDefined();
+            container.dispose();
+        });
+
+        it("can add and dispose a service with no contracts", async () => {
+            const container = new ServiceContainer("test");
+            const factory = vi.fn(async () => ({}));
+            const def: ServiceDefinition<[]> = { friendlyName: "svc", factory };
+            const handle = await container.addServiceAsync(def);
+
+            expect(factory).toHaveBeenCalledOnce();
+            handle.dispose();
+            container.dispose();
+        });
+
+        it("calls dispose on service instance when removed", async () => {
+            const container = new ServiceContainer("test");
+            const disposeSpy = vi.fn();
+            const def: ServiceDefinition<[IContractA]> = {
+                friendlyName: "svc",
+                produces: [ContractA],
+                factory: async () => ({ value: "a", dispose: disposeSpy }),
+            };
+
+            const handle = await container.addServiceAsync(def);
+            handle.dispose();
+
+            expect(disposeSpy).toHaveBeenCalledOnce();
+            container.dispose();
+        });
+
+        it("handles service factory returning void", async () => {
+            const container = new ServiceContainer("test");
+            const factory = vi.fn(async () => {});
+            const def: ServiceDefinition<[]> = { friendlyName: "svc", factory };
+
+            const handle = await container.addServiceAsync(def);
+            expect(factory).toHaveBeenCalledOnce();
+            handle.dispose();
+            container.dispose();
+        });
+    });
+
+    // ---------------------------------------------------------------------------
+    // Dependency resolution
+    // ---------------------------------------------------------------------------
+
+    describe("dependency resolution", () => {
+        it("passes produced services as arguments to consuming factories", async () => {
+            const container = new ServiceContainer("test");
+            const serviceA: IContractA & Partial<IDisposable> = { value: "hello" };
+
+            const defA: ServiceDefinition<[IContractA]> = {
+                friendlyName: "A",
+                produces: [ContractA],
+                factory: async () => serviceA,
+            };
+
+            const consumerFactory = vi.fn(async () => ({}));
+            const defConsumer: ServiceDefinition<[], [IContractA]> = {
+                friendlyName: "Consumer",
+                consumes: [ContractA],
+                factory: consumerFactory,
+            };
+
+            await container.addServicesAsync(defA, defConsumer);
+            expect(consumerFactory).toHaveBeenCalledWith(serviceA, undefined);
+
+            container.dispose();
+        });
+
+        it("sorts services by dependency order regardless of registration order", async () => {
+            const container = new ServiceContainer("test");
+            const order: string[] = [];
+
+            const defA: ServiceDefinition<[IContractA]> = {
+                friendlyName: "A",
+                produces: [ContractA],
+                factory: async () => {
+                    order.push("A");
+                    return { value: "a" };
+                },
+            };
+
+            const defB: ServiceDefinition<[], [IContractA]> = {
+                friendlyName: "B",
+                consumes: [ContractA],
+                factory: async () => {
+                    order.push("B");
+                },
+            };
+
+            // Register consumer before producer.
+            await container.addServicesAsync(defB, defA);
+            expect(order).toEqual(["A", "B"]);
+
+            container.dispose();
+        });
+
+        it("supports a chain of dependencies (A → B → C)", async () => {
+            const container = new ServiceContainer("test");
+            const order: string[] = [];
+
+            const defA: ServiceDefinition<[IContractA]> = {
+                friendlyName: "A",
+                produces: [ContractA],
+                factory: async () => {
+                    order.push("A");
+                    return { value: "a" };
+                },
+            };
+
+            const defB: ServiceDefinition<[IContractB], [IContractA]> = {
+                friendlyName: "B",
+                produces: [ContractB],
+                consumes: [ContractA],
+                factory: async () => {
+                    order.push("B");
+                    return { value: "b" };
+                },
+            };
+
+            const defC: ServiceDefinition<[], [IContractB]> = {
+                friendlyName: "C",
+                consumes: [ContractB],
+                factory: async () => {
+                    order.push("C");
+                },
+            };
+
+            await container.addServicesAsync(defC, defB, defA);
+            expect(order).toEqual(["A", "B", "C"]);
+
+            container.dispose();
+        });
+    });
+
+    // ---------------------------------------------------------------------------
+    // Duplicate contracts
+    // ---------------------------------------------------------------------------
+
+    describe("duplicate contracts", () => {
+        it("throws when adding two services that produce the same contract", async () => {
+            const container = new ServiceContainer("test");
+            const def1: ServiceDefinition<[IContractA]> = {
+                friendlyName: "First",
+                produces: [ContractA],
+                factory: async () => ({ value: "1" }),
+            };
+
+            await container.addServiceAsync(def1);
+
+            const def2: ServiceDefinition<[IContractA]> = {
+                friendlyName: "Second",
+                produces: [ContractA],
+                factory: async () => ({ value: "2" }),
+            };
+
+            await expect(container.addServiceAsync(def2)).rejects.toThrow(/already been added/);
+            container.dispose();
+        });
+    });
+
+    // ---------------------------------------------------------------------------
+    // Missing dependencies
+    // ---------------------------------------------------------------------------
+
+    describe("missing dependencies", () => {
+        it("throws when a consumed contract is not registered", async () => {
+            const container = new ServiceContainer("test");
+            const def: ServiceDefinition<[], [IContractA]> = {
+                friendlyName: "Consumer",
+                consumes: [ContractA],
+                factory: async () => {},
+            };
+
+            await expect(container.addServiceAsync(def)).rejects.toThrow(/has not been registered/);
+            container.dispose();
+        });
+    });
+
+    // ---------------------------------------------------------------------------
+    // Removal and dependent checking
+    // ---------------------------------------------------------------------------
+
+    describe("service removal", () => {
+        it("throws when removing a service that still has dependents", async () => {
+            const container = new ServiceContainer("test");
+
+            const defA: ServiceDefinition<[IContractA]> = {
+                friendlyName: "A",
+                produces: [ContractA],
+                factory: async () => ({ value: "a" }),
+            };
+
+            const defConsumer: ServiceDefinition<[], [IContractA]> = {
+                friendlyName: "Consumer",
+                consumes: [ContractA],
+                factory: async () => {},
+            };
+
+            const handleA = await container.addServiceAsync(defA);
+            await container.addServiceAsync(defConsumer);
+
+            expect(() => handleA.dispose()).toThrow(/has dependents.*Consumer/);
+            container.dispose();
+        });
+
+        it("allows removal after dependent is removed first", async () => {
+            const container = new ServiceContainer("test");
+
+            const defA: ServiceDefinition<[IContractA]> = {
+                friendlyName: "A",
+                produces: [ContractA],
+                factory: async () => ({ value: "a" }),
+            };
+
+            const defConsumer: ServiceDefinition<[], [IContractA]> = {
+                friendlyName: "Consumer",
+                consumes: [ContractA],
+                factory: async () => {},
+            };
+
+            const handleA = await container.addServiceAsync(defA);
+            const handleConsumer = await container.addServiceAsync(defConsumer);
+
+            handleConsumer.dispose();
+            expect(() => handleA.dispose()).not.toThrow();
+            container.dispose();
+        });
+
+        it("disposes services in reverse order via addServicesAsync handle", async () => {
+            const container = new ServiceContainer("test");
+            const order: string[] = [];
+
+            const defA: ServiceDefinition<[IContractA]> = {
+                friendlyName: "A",
+                produces: [ContractA],
+                factory: async () => ({
+                    value: "a",
+                    dispose: () => order.push("A disposed"),
+                }),
+            };
+
+            const defConsumer: ServiceDefinition<[], [IContractA]> = {
+                friendlyName: "Consumer",
+                consumes: [ContractA],
+                factory: async () => ({
+                    dispose: () => order.push("Consumer disposed"),
+                }),
+            };
+
+            const handle = await container.addServicesAsync(defA, defConsumer);
+            handle.dispose();
+
+            expect(order).toEqual(["Consumer disposed", "A disposed"]);
+            container.dispose();
+        });
+    });
+
+    // ---------------------------------------------------------------------------
+    // Disposed container
+    // ---------------------------------------------------------------------------
+
+    describe("disposed container", () => {
+        it("throws when adding to a disposed container", async () => {
+            const container = new ServiceContainer("test");
+            container.dispose();
+
+            const def: ServiceDefinition<[]> = { friendlyName: "svc", factory: async () => {} };
+            await expect(container.addServiceAsync(def)).rejects.toThrow(/disposed/);
+        });
+
+        it("throws when adding services to a disposed container via addServicesAsync", async () => {
+            const container = new ServiceContainer("test");
+            container.dispose();
+
+            const def: ServiceDefinition<[]> = { friendlyName: "svc", factory: async () => {} };
+            await expect(container.addServicesAsync(def)).rejects.toThrow(/disposed/);
+        });
+    });
+
+    // ---------------------------------------------------------------------------
+    // Abort signal
+    // ---------------------------------------------------------------------------
+
+    describe("abort signal", () => {
+        it("passes abort signal to service factory", async () => {
+            const container = new ServiceContainer("test");
+            const factory = vi.fn(async () => {});
+            const controller = new AbortController();
+
+            await container.addServiceAsync({ friendlyName: "svc", factory }, controller.signal);
+            expect(factory).toHaveBeenCalledWith(controller.signal);
+
+            container.dispose();
+        });
+
+        it("passes abort signal as last arg after dependencies", async () => {
+            const container = new ServiceContainer("test");
+            const serviceA: IContractA & Partial<IDisposable> = { value: "hello" };
+
+            const defA: ServiceDefinition<[IContractA]> = {
+                friendlyName: "A",
+                produces: [ContractA],
+                factory: async () => serviceA,
+            };
+
+            const consumerFactory = vi.fn(async () => {});
+            const defConsumer: ServiceDefinition<[], [IContractA]> = {
+                friendlyName: "Consumer",
+                consumes: [ContractA],
+                factory: consumerFactory,
+            };
+
+            const controller = new AbortController();
+            await container.addServicesAsync(defA, defConsumer, controller.signal);
+            expect(consumerFactory).toHaveBeenCalledWith(serviceA, controller.signal);
+
+            container.dispose();
+        });
+    });
+
+    // ---------------------------------------------------------------------------
+    // Factory error handling
+    // ---------------------------------------------------------------------------
+
+    describe("factory errors", () => {
+        it("rolls back all services if a factory throws during addServicesAsync", async () => {
+            const container = new ServiceContainer("test");
+            const disposeSpy = vi.fn();
+
+            const defA: ServiceDefinition<[IContractA]> = {
+                friendlyName: "A",
+                produces: [ContractA],
+                factory: async () => ({ value: "a", dispose: disposeSpy }),
+            };
+
+            const defFailing: ServiceDefinition<[], [IContractA]> = {
+                friendlyName: "Failing",
+                consumes: [ContractA],
+                factory: async () => {
+                    throw new Error("Factory failed");
+                },
+            };
+
+            await expect(container.addServicesAsync(defA, defFailing)).rejects.toThrow("Factory failed");
+
+            // A should have been cleaned up.
+            expect(disposeSpy).toHaveBeenCalledOnce();
+
+            // Container should still be usable.
+            const defB: ServiceDefinition<[IContractA]> = {
+                friendlyName: "B",
+                produces: [ContractA],
+                factory: async () => ({ value: "b" }),
+            };
+            const handle = await container.addServiceAsync(defB);
+            handle.dispose();
+            container.dispose();
+        });
+    });
+
+    // ---------------------------------------------------------------------------
+    // Parent-child containers
+    // ---------------------------------------------------------------------------
+
+    describe("parent-child containers", () => {
+        it("resolves dependencies from parent container", async () => {
+            const parent = new ServiceContainer("parent");
+            const serviceA: IContractA & Partial<IDisposable> = { value: "from parent" };
+
+            await parent.addServiceAsync({
+                friendlyName: "A",
+                produces: [ContractA],
+                factory: async () => serviceA,
+            } satisfies ServiceDefinition<[IContractA]>);
+
+            const child = new ServiceContainer("child", parent);
+            const consumerFactory = vi.fn(async () => {});
+            await child.addServiceAsync({
+                friendlyName: "Consumer",
+                consumes: [ContractA],
+                factory: consumerFactory,
+            } satisfies ServiceDefinition<[], [IContractA]>);
+
+            expect(consumerFactory).toHaveBeenCalledWith(serviceA, undefined);
+
+            child.dispose();
+            parent.dispose();
+        });
+
+        it("prefers local services over parent services", async () => {
+            const parent = new ServiceContainer("parent");
+            await parent.addServiceAsync({
+                friendlyName: "ParentA",
+                produces: [ContractA],
+                factory: async () => contractA("parent"),
+            } satisfies ServiceDefinition<[IContractA]>);
+
+            const child = new ServiceContainer("child", parent);
+            const childA: IContractA & Partial<IDisposable> = { value: "child" };
+            await child.addServiceAsync({
+                friendlyName: "ChildA",
+                produces: [ContractA],
+                factory: async () => childA,
+            } satisfies ServiceDefinition<[IContractA]>);
+
+            const consumerFactory = vi.fn(async () => {});
+            await child.addServiceAsync({
+                friendlyName: "Consumer",
+                consumes: [ContractA],
+                factory: consumerFactory,
+            } satisfies ServiceDefinition<[], [IContractA]>);
+
+            expect(consumerFactory).toHaveBeenCalledWith(childA, undefined);
+
+            child.dispose();
+            parent.dispose();
+        });
+
+        it("throws when disposing parent with active children", () => {
+            const parent = new ServiceContainer("parent");
+            const _child = new ServiceContainer("child", parent);
+
+            expect(() => parent.dispose()).toThrow(/active child container/);
+
+            _child.dispose();
+            parent.dispose();
+        });
+
+        it("removes child from parent on dispose", () => {
+            const parent = new ServiceContainer("parent");
+            const child = new ServiceContainer("child", parent);
+
+            child.dispose();
+            expect(() => parent.dispose()).not.toThrow();
+        });
+
+        it("tracks parent dependency as dependent for removal checks", async () => {
+            const parent = new ServiceContainer("parent");
+            const handleA = await parent.addServiceAsync({
+                friendlyName: "A",
+                produces: [ContractA],
+                factory: async () => contractA("a"),
+            } satisfies ServiceDefinition<[IContractA]>);
+
+            const child = new ServiceContainer("child", parent);
+            await child.addServiceAsync({
+                friendlyName: "Consumer",
+                consumes: [ContractA],
+                factory: async () => {},
+            } satisfies ServiceDefinition<[], [IContractA]>);
+
+            expect(() => handleA.dispose()).toThrow(/has dependents/);
+
+            child.dispose();
+            expect(() => handleA.dispose()).not.toThrow();
+            parent.dispose();
+        });
+
+        it("cleans up parent dependent tracking when child service is removed", async () => {
+            const parent = new ServiceContainer("parent");
+            const handleA = await parent.addServiceAsync({
+                friendlyName: "A",
+                produces: [ContractA],
+                factory: async () => contractA("a"),
+            } satisfies ServiceDefinition<[IContractA]>);
+
+            const child = new ServiceContainer("child", parent);
+            const handleConsumer = await child.addServiceAsync({
+                friendlyName: "Consumer",
+                consumes: [ContractA],
+                factory: async () => {},
+            } satisfies ServiceDefinition<[], [IContractA]>);
+
+            handleConsumer.dispose();
+            expect(() => handleA.dispose()).not.toThrow();
+
+            child.dispose();
+            parent.dispose();
+        });
+    });
+
+    // ---------------------------------------------------------------------------
+    // dispose() behavior
+    // ---------------------------------------------------------------------------
+
+    describe("dispose", () => {
+        it("disposes all services in reverse order", async () => {
+            const container = new ServiceContainer("test");
+            const order: string[] = [];
+
+            await container.addServiceAsync({
+                friendlyName: "First",
+                produces: [ContractA],
+                factory: async () => ({ value: "a", dispose: () => order.push("First") }),
+            } satisfies ServiceDefinition<[IContractA]>);
+
+            await container.addServiceAsync({
+                friendlyName: "Second",
+                consumes: [ContractA],
+                factory: async () => ({ dispose: () => order.push("Second") }),
+            } satisfies ServiceDefinition<[], [IContractA]>);
+
+            container.dispose();
+            expect(order).toEqual(["Second", "First"]);
+        });
+
+        it("clears all internal state on dispose", async () => {
+            const container = new ServiceContainer("test");
+
+            await container.addServiceAsync({
+                friendlyName: "A",
+                produces: [ContractA],
+                factory: async () => contractA("a"),
+            } satisfies ServiceDefinition<[IContractA]>);
+
+            container.dispose();
+
+            const def: ServiceDefinition<[]> = { friendlyName: "B", factory: async () => {} };
+            await expect(container.addServiceAsync(def)).rejects.toThrow(/disposed/);
+        });
+    });
+
+    // ---------------------------------------------------------------------------
+    // Multiple contracts
+    // ---------------------------------------------------------------------------
+
+    describe("multiple contracts", () => {
+        it("allows a single service to produce multiple contracts", async () => {
+            const container = new ServiceContainer("test");
+            const multiService = contractAB("multi");
+
+            await container.addServiceAsync({
+                friendlyName: "Multi",
+                produces: [ContractA, ContractB],
+                factory: async () => multiService,
+            } satisfies ServiceDefinition<[IContractA, IContractB]>);
+
+            const consumerFactory = vi.fn(async () => {});
+            await container.addServiceAsync({
+                friendlyName: "ConsumerA",
+                consumes: [ContractA],
+                factory: consumerFactory,
+            } satisfies ServiceDefinition<[], [IContractA]>);
+
+            expect(consumerFactory).toHaveBeenCalledWith(multiService, undefined);
+
+            container.dispose();
+        });
+
+        it("tracks dependents per contract for multi-contract services", async () => {
+            const container = new ServiceContainer("test");
+            const multiService = contractAB("multi");
+
+            const handleMulti = await container.addServiceAsync({
+                friendlyName: "Multi",
+                produces: [ContractA, ContractB],
+                factory: async () => multiService,
+            } satisfies ServiceDefinition<[IContractA, IContractB]>);
+
+            const handleConsumer = await container.addServiceAsync({
+                friendlyName: "Consumer",
+                consumes: [ContractA],
+                factory: async () => {},
+            } satisfies ServiceDefinition<[], [IContractA]>);
+
+            expect(() => handleMulti.dispose()).toThrow(/has dependents/);
+
+            handleConsumer.dispose();
+            expect(() => handleMulti.dispose()).not.toThrow();
+
+            container.dispose();
+        });
+    });
+
+    // ---------------------------------------------------------------------------
+    // Synchronous factory
+    // ---------------------------------------------------------------------------
+
+    describe("synchronous factory", () => {
+        it("works with a synchronous factory function", async () => {
+            const container = new ServiceContainer("test");
+
+            await container.addServiceAsync({
+                friendlyName: "SyncService",
+                produces: [ContractA],
+                factory: () => contractA("sync"),
+            } satisfies ServiceDefinition<[IContractA]>);
+
+            const consumerFactory = vi.fn(async () => {});
+            const handleConsumer = await container.addServiceAsync({
+                friendlyName: "Consumer",
+                consumes: [ContractA],
+                factory: consumerFactory,
+            } satisfies ServiceDefinition<[], [IContractA]>);
+
+            expect((consumerFactory.mock.calls[0] as unknown[])[0]).toHaveProperty("value", "sync");
+
+            handleConsumer.dispose();
+            container.dispose();
+        });
+    });
+});
diff --git a/packages/dev/inspector-v2/test/unit/services/inspectableBridgeService.test.ts b/packages/dev/inspector-v2/test/unit/services/inspectableBridgeService.test.ts
new file mode 100644
index 000000000000..11702865bcea
--- /dev/null
+++ b/packages/dev/inspector-v2/test/unit/services/inspectableBridgeService.test.ts
@@ -0,0 +1,107 @@
+import { describe, it, expect } from "vitest";
+import { InspectableCommandRegistryIdentity } from "../../../src/services/cli/inspectableCommandRegistry";
+import { CliConnectionStatusIdentity } from "../../../src/services/cli/cliConnectionStatus";
+import { MakeInspectableBridgeServiceDefinition } from "../../../src/services/cli/inspectableBridgeService";
+
+describe("InspectableBridgeService", () => {
+    describe("service definition", () => {
+        it("produces InspectableCommandRegistryIdentity", () => {
+            const definition = MakeInspectableBridgeServiceDefinition({ port: 4400, name: "test" });
+            expect(definition.produces).toContain(InspectableCommandRegistryIdentity);
+        });
+
+        it("produces CliConnectionStatusIdentity", () => {
+            const definition = MakeInspectableBridgeServiceDefinition({ port: 4400, name: "test" });
+            expect(definition.produces).toContain(CliConnectionStatusIdentity);
+        });
+
+        it("has a friendly name", () => {
+            const definition = MakeInspectableBridgeServiceDefinition({ port: 4400, name: "test" });
+            expect(definition.friendlyName).toBe("Inspectable Bridge Service");
+        });
+    });
+
+    describe("command registry", () => {
+        it("can register and unregister a command", async () => {
+            const definition = MakeInspectableBridgeServiceDefinition({ port: 0, name: "test" });
+            const registry = await definition.factory();
+
+            const disposal = registry.addCommand({
+                id: "test-cmd",
+                description: "A test command",
+                executeAsync: async () => "ok",
+            });
+
+            expect(disposal).toBeDefined();
+            expect(disposal.dispose).toBeInstanceOf(Function);
+
+            disposal.dispose();
+            registry.dispose?.();
+        });
+
+        it("throws when registering a duplicate command id", async () => {
+            const definition = MakeInspectableBridgeServiceDefinition({ port: 0, name: "test" });
+            const registry = await definition.factory();
+
+            registry.addCommand({
+                id: "dup-cmd",
+                description: "First",
+                executeAsync: async () => "first",
+            });
+
+            expect(() => {
+                registry.addCommand({
+                    id: "dup-cmd",
+                    description: "Second",
+                    executeAsync: async () => "second",
+                });
+            }).toThrow("Command 'dup-cmd' is already registered.");
+
+            registry.dispose?.();
+        });
+
+        it("allows re-registration after disposal", async () => {
+            const definition = MakeInspectableBridgeServiceDefinition({ port: 0, name: "test" });
+            const registry = await definition.factory();
+
+            const token = registry.addCommand({
+                id: "reuse-cmd",
+                description: "Reusable",
+                executeAsync: async () => "ok",
+            });
+
+            token.dispose();
+
+            const token2 = registry.addCommand({
+                id: "reuse-cmd",
+                description: "Reusable again",
+                executeAsync: async () => "ok again",
+            });
+
+            expect(token2).toBeDefined();
+            token2.dispose();
+            registry.dispose?.();
+        });
+    });
+
+    describe("connection status", () => {
+        it("starts disconnected", async () => {
+            const definition = MakeInspectableBridgeServiceDefinition({ port: 0, name: "test" });
+            const registry = await definition.factory();
+
+            expect(registry.isConnected).toBe(false);
+
+            registry.dispose?.();
+        });
+
+        it("exposes onConnectionStatusChanged observable", async () => {
+            const definition = MakeInspectableBridgeServiceDefinition({ port: 0, name: "test" });
+            const registry = await definition.factory();
+
+            expect(registry.onConnectionStatusChanged).toBeDefined();
+            expect(registry.onConnectionStatusChanged.add).toBeInstanceOf(Function);
+
+            registry.dispose?.();
+        });
+    });
+});
diff --git a/packages/dev/inspector-v2/tsconfig.webpack.json b/packages/dev/inspector-v2/tsconfig.webpack.json
new file mode 100644
index 000000000000..45ac0d717ef4
--- /dev/null
+++ b/packages/dev/inspector-v2/tsconfig.webpack.json
@@ -0,0 +1,9 @@
+{
+    "extends": ["../../../tsconfig.build.json", "./tsconfig.common.json"],
+
+    "compilerOptions": {
+        "rootDir": "./src"
+    },
+
+    "include": ["./src/**/*"]
+}
diff --git a/packages/dev/inspector-v2/webpack.config.js b/packages/dev/inspector-v2/webpack.config.js
index 041dc0fae77d..eb951a624307 100644
--- a/packages/dev/inspector-v2/webpack.config.js
+++ b/packages/dev/inspector-v2/webpack.config.js
@@ -6,6 +6,10 @@ module.exports = (env) => {
     return {
         entry: "./test/app/index.tsx",
 
+        snapshot: {
+            managedPaths: [/^(.+?[\\/]node_modules[\\/](?!(@fluentui-contrib[\\/]react-virtualizer)))/],
+        },
+
         ...webpackTools.commonDevWebpackConfiguration(
             {
                 ...env,
@@ -50,7 +54,7 @@ module.exports = (env) => {
                 ],
                 enableFastRefresh: !production,
                 tsOptions: {
-                    configFile: "tsconfig.build.json",
+                    configFile: "tsconfig.webpack.json",
                     transpileOnly: true,
                 },
             }),
diff --git a/packages/dev/sharedUiComponents/src/fluent/primitives/toast.tsx b/packages/dev/sharedUiComponents/src/fluent/primitives/toast.tsx
index f9751a9acd6f..1556d76ea5b7 100644
--- a/packages/dev/sharedUiComponents/src/fluent/primitives/toast.tsx
+++ b/packages/dev/sharedUiComponents/src/fluent/primitives/toast.tsx
@@ -1,30 +1,65 @@
-import { type FunctionComponent, type PropsWithChildren, createContext, useCallback, useContext } from "react";
+import { type FunctionComponent, type PropsWithChildren, type Ref, createContext, useCallback, useContext, useImperativeHandle } from "react";
 
-import { FluentProvider, Toast, Toaster, ToastTitle, useFluent, useId, useToastController } from "@fluentui/react-components";
+import { type ToastIntent, FluentProvider, Toast, Toaster, ToastTitle, useFluent, useId, useToastController } from "@fluentui/react-components";
+
+/**
+ * Options for showing a toast notification.
+ */
+export type ToastOptions = {
+    /**
+     * The intent of the toast notification. Defaults to "info".
+     */
+    intent?: ToastIntent;
+};
 
 type ToastContextType = {
-    showToast: (message: string) => void;
+    showToast: (message: string, options?: ToastOptions) => void;
+};
+
+/**
+ * Imperative handle exposed by {@link ToastProvider} via its `imperativeRef` prop.
+ */
+export type ToastHandle = {
+    /**
+     * Shows a toast notification with the given message.
+     * @param message The message to display.
+     * @param options Optional toast configuration.
+     */
+    showToast: (message: string, options?: ToastOptions) => void;
 };
 
 const ToastContext = createContext<ToastContextType>({ showToast: () => {} });
 
-export const ToastProvider: FunctionComponent<PropsWithChildren> = ({ children }) => {
+export type ToastProviderProps = PropsWithChildren<{
+    /**
+     * A ref that exposes the {@link ToastHandle} imperative API.
+     */
+    imperativeRef?: Ref<ToastHandle>;
+}>;
+
+/**
+ * Provides toast notification functionality to child components via context and an optional imperative ref.
+ * @returns The toast provider component tree.
+ */
+export const ToastProvider: FunctionComponent<ToastProviderProps> = ({ children, imperativeRef }) => {
     const toasterId = useId("toaster");
     const { dispatchToast } = useToastController(toasterId);
     const { targetDocument } = useFluent();
 
     const showToast = useCallback(
-        (message: string) => {
+        (message: string, options?: ToastOptions) => {
             dispatchToast(
                 <Toast>
                     <ToastTitle>{message}</ToastTitle>
                 </Toast>,
-                { intent: "info", timeout: 2000 }
+                { intent: options?.intent ?? "info", timeout: 2000 }
             );
         },
         [dispatchToast]
     );
 
+    useImperativeHandle(imperativeRef, () => ({ showToast }), [showToast]);
+
     return (
         <ToastContext.Provider value={{ showToast }}>
             {children}
diff --git a/packages/public/@babylonjs/core/readme.md b/packages/public/@babylonjs/core/readme.md
index 6b894adc9f29..d2cbec0972eb 100644
--- a/packages/public/@babylonjs/core/readme.md
+++ b/packages/public/@babylonjs/core/readme.md
@@ -101,3 +101,7 @@ Please see the [contribution guidelines](https://github.com/BabylonJS/Babylon.js
 ## Features
 
 To get a complete list of supported features, please visit our [website](https://www.babylonjs.com/).
+
+## Inspector
+
+The [`@babylonjs/inspector`](https://www.npmjs.com/package/@babylonjs/inspector) package provides a diagnostic tool for understanding scene state and rendering. It includes a visual UI for humans and a CLI for AI agents. See the [Inspector documentation](https://doc.babylonjs.com/toolsAndResources/inspectorv2/) for more details.
diff --git a/packages/public/@babylonjs/inspector-v2/.gitignore b/packages/public/@babylonjs/inspector-v2/.gitignore
new file mode 100644
index 000000000000..44519b5db33e
--- /dev/null
+++ b/packages/public/@babylonjs/inspector-v2/.gitignore
@@ -0,0 +1 @@
+bin/
diff --git a/packages/public/@babylonjs/inspector-v2/package.json b/packages/public/@babylonjs/inspector-v2/package.json
index bc97fc55f2ec..dbcf934ba055 100644
--- a/packages/public/@babylonjs/inspector-v2/package.json
+++ b/packages/public/@babylonjs/inspector-v2/package.json
@@ -12,7 +12,11 @@
         },
         "./package.json": "./package.json"
     },
+    "bin": {
+        "babylon-inspector": "./bin/inspector-cli.mjs"
+    },
     "files": [
+        "bin/**/*.mjs",
         "lib/**/*.js",
         "lib/**/*.d.ts",
         "lib/**/*.map",
@@ -21,9 +25,10 @@
     ],
     "scripts": {
         "build": "npm run clean && npm run bundle",
-        "clean": "rimraf lib && rimraf dist && rimraf *.tsbuildinfo -g",
-        "bundle": "npm run bundle:lib",
+        "clean": "rimraf lib && rimraf bin && rimraf dist && rimraf *.tsbuildinfo -g",
+        "bundle": "npm run bundle:lib && npm run bundle:cli",
         "bundle:lib": "rollup -c rollup.config.lib.mjs && tsc -p tsconfig.build.dts.json && build-tools -c tp --outDir ./lib --buildType es6 --basePackage @babylonjs/inspector --appendJS",
+        "bundle:cli": "rollup -c rollup.config.cli.mjs",
         "pack": "npm run build && npm pack"
     },
     "peerDependencies": {
@@ -48,9 +53,11 @@
         "@rollup/plugin-commonjs": "^26.0.1",
         "@rollup/plugin-node-resolve": "^15.2.3",
         "@rollup/plugin-typescript": "^11.1.6",
+        "@types/ws": "^8.5.0",
         "chalk": "^5.3.0",
         "rollup": "^4.59.0",
-        "rollup-plugin-dts": "^6.1.1"
+        "rollup-plugin-dts": "^6.1.1",
+        "ws": "^8.18.0"
     },
     "keywords": [
         "3D",
diff --git a/packages/public/@babylonjs/inspector-v2/readme.md b/packages/public/@babylonjs/inspector-v2/readme.md
index 1481645fcf68..c3b2c5eec168 100644
--- a/packages/public/@babylonjs/inspector-v2/readme.md
+++ b/packages/public/@babylonjs/inspector-v2/readme.md
@@ -21,3 +21,30 @@ import { ShowInspector } from "@babylonjs/inspector";
 
 ShowInspector(scene);
 ```
+
+## Headless Inspectable (No UI)
+
+You can make a scene inspectable for the CLI without showing the Inspector UI by calling `StartInspectable`:
+
+```ts
+import { StartInspectable } from "@babylonjs/inspector";
+
+// Your code that sets up a Babylon.js scene...
+
+const token = StartInspectable(scene);
+
+// When you're done, dispose the token to disconnect:
+token.dispose();
+```
+
+`StartInspectable` connects the scene to the Inspector CLI bridge, enabling CLI commands like querying entities, taking screenshots, and capturing performance traces — all without rendering any Inspector UI. `ShowInspector` automatically calls `StartInspectable` internally.
+
+## Inspector CLI
+
+While the Inspector UI is designed for humans, the Inspector CLI is designed for AI agents. It provides machine-friendly JSON output for querying scene entities, capturing screenshots, collecting performance data, and more.
+
+To get started:
+
+```bash
+npx babylon-inspector --help
+```
diff --git a/packages/public/@babylonjs/inspector-v2/rollup.config.cli.mjs b/packages/public/@babylonjs/inspector-v2/rollup.config.cli.mjs
new file mode 100644
index 000000000000..b7a9ef22e521
--- /dev/null
+++ b/packages/public/@babylonjs/inspector-v2/rollup.config.cli.mjs
@@ -0,0 +1,40 @@
+import typescript from "@rollup/plugin-typescript";
+import { nodeResolve } from "@rollup/plugin-node-resolve";
+import commonjs from "@rollup/plugin-commonjs";
+
+const commonPlugins = [
+    typescript({ tsconfig: "tsconfig.cli.json" }),
+    nodeResolve({ preferBuiltins: true }),
+    commonjs(),
+];
+
+const cliConfig = {
+    input: "../../../dev/inspector-v2/src/cli/cli.ts",
+    output: {
+        file: "bin/inspector-cli.mjs",
+        format: "es",
+        sourcemap: false,
+        banner: "#!/usr/bin/env node\n",
+    },
+    plugins: commonPlugins,
+    onwarn(warning, warn) {
+        // Treat all other warnings as errors.
+        throw new Error(warning.message);
+    },
+};
+
+const bridgeConfig = {
+    input: "../../../dev/inspector-v2/src/cli/bridge.ts",
+    output: {
+        file: "bin/inspector-bridge.mjs",
+        format: "es",
+        sourcemap: false,
+    },
+    plugins: commonPlugins,
+    onwarn(warning, warn) {
+        // Treat all other warnings as errors.
+        throw new Error(warning.message);
+    },
+};
+
+export default [cliConfig, bridgeConfig];
diff --git a/packages/public/@babylonjs/inspector-v2/tsconfig.build.lib.json b/packages/public/@babylonjs/inspector-v2/tsconfig.build.lib.json
index 344bacf63136..756e521463d2 100644
--- a/packages/public/@babylonjs/inspector-v2/tsconfig.build.lib.json
+++ b/packages/public/@babylonjs/inspector-v2/tsconfig.build.lib.json
@@ -1,14 +1,12 @@
-{
-    "extends": "../../../../tsconfig.build.json",
-    "compilerOptions": {
-        "outDir": "./lib",
-        "rootDir": "../../../",
-        "declaration": false,
-        "target": "ES2020",
-        "importHelpers": true
-    },
-    "include": [
-        "../../../dev/inspector-v2/src/**/*",
-        "../../../dev/sharedUiComponents/src/**/*"
-    ]
-}
+{
+    "extends": "../../../../tsconfig.build.json",
+    "compilerOptions": {
+        "outDir": "./lib",
+        "rootDir": "../../../",
+        "declaration": false,
+        "target": "ES2020",
+        "importHelpers": true
+    },
+    "include": ["../../../dev/inspector-v2/src/**/*", "../../../dev/sharedUiComponents/src/**/*"],
+    "exclude": ["../../../dev/inspector-v2/src/cli/**/*"]
+}
diff --git a/packages/public/@babylonjs/inspector-v2/tsconfig.cli.json b/packages/public/@babylonjs/inspector-v2/tsconfig.cli.json
new file mode 100644
index 000000000000..47f6128a11f1
--- /dev/null
+++ b/packages/public/@babylonjs/inspector-v2/tsconfig.cli.json
@@ -0,0 +1,16 @@
+{
+    "compilerOptions": {
+        "target": "ES2020",
+        "module": "ES2020",
+        "moduleResolution": "bundler",
+        "outDir": "./bin",
+        "rootDir": "../../../dev/inspector-v2/src/cli",
+        "declaration": false,
+        "strict": true,
+        "esModuleInterop": true,
+        "skipLibCheck": true,
+        "forceConsistentCasingInFileNames": true,
+        "resolveJsonModule": true
+    },
+    "include": ["../../../dev/inspector-v2/src/cli/**/*"]
+}
diff --git a/packages/public/umd/babylonjs-inspector-v2/readme.md b/packages/public/umd/babylonjs-inspector-v2/readme.md
index 9b9fa0889f07..413158f5cb7b 100644
--- a/packages/public/umd/babylonjs-inspector-v2/readme.md
+++ b/packages/public/umd/babylonjs-inspector-v2/readme.md
@@ -35,3 +35,28 @@ INSPECTOR.ShowInspector(scene);
     </body>
 </html>
 ```
+
+## Headless Inspectable (No UI)
+
+You can make a scene inspectable for the CLI without showing the Inspector UI by calling `StartInspectable`:
+
+```ts
+// Your code that sets up a Babylon.js scene...
+
+const token = INSPECTOR.StartInspectable(scene);
+
+// When you're done, dispose the token to disconnect:
+token.dispose();
+```
+
+`StartInspectable` connects the scene to the Inspector CLI bridge, enabling CLI commands like querying entities, taking screenshots, and capturing performance traces — all without rendering any Inspector UI. `ShowInspector` automatically calls `StartInspectable` internally.
+
+## Inspector CLI
+
+While the Inspector UI is designed for humans, the Inspector CLI is designed for AI agents. It provides machine-friendly JSON output for querying scene entities, capturing screenshots, collecting performance data, and more.
+
+To get started:
+
+```bash
+npx babylon-inspector --help
+```
diff --git a/packages/public/umd/babylonjs/readme.md b/packages/public/umd/babylonjs/readme.md
index ab2d2f1718fa..f5b6b7ab5833 100644
--- a/packages/public/umd/babylonjs/readme.md
+++ b/packages/public/umd/babylonjs/readme.md
@@ -100,3 +100,7 @@ Please see the [Contributing Guidelines](https://github.com/BabylonJS/Babylon.js
 ## Features
 
 To get a complete list of supported features, please visit [Babylon.js website](https://www.babylonjs.com/).
+
+## Inspector
+
+The [`babylonjs-inspector`](https://www.npmjs.com/package/babylonjs-inspector) package provides a diagnostic tool for understanding scene state and rendering. It includes a visual UI for humans and a CLI for AI agents. See the [Inspector documentation](https://doc.babylonjs.com/toolsAndResources/inspectorv2/) for more details.